486 lines
25 KiB
TypeScript
486 lines
25 KiB
TypeScript
// SQLite (встроенный node:sqlite): задачи ComfyUI, батчи картинок и их источники, значения полей форм.
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { DatabaseSync } from 'node:sqlite';
|
|
import type {
|
|
BatchImage, BatchState, FileRef, ImageBatch, Job, JobState, ModelArtifacts, Project, SettingsPage, Text2ImgInput,
|
|
TextureArtifacts,
|
|
} from '../shared/api.ts';
|
|
import { DB_PATH } from './config.ts';
|
|
|
|
fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
|
|
const db = new DatabaseSync(DB_PATH);
|
|
db.exec(`
|
|
PRAGMA journal_mode = WAL;
|
|
PRAGMA foreign_keys = ON;
|
|
|
|
-- задачи ComfyUI (все типы); отслеживаются трекером
|
|
CREATE TABLE IF NOT EXISTS jobs (
|
|
id TEXT PRIMARY KEY, -- prompt_id ComfyUI
|
|
type TEXT NOT NULL, -- text2img | cleanup | model
|
|
created INTEGER NOT NULL, -- мс
|
|
state TEXT NOT NULL, -- pending | done | error
|
|
error TEXT,
|
|
source TEXT, -- JSON FileRef исходника
|
|
params TEXT NOT NULL, -- JSON параметров
|
|
images TEXT NOT NULL DEFAULT '[]', -- JSON FileRef[]
|
|
models TEXT NOT NULL DEFAULT '[]' -- JSON FileRef[]
|
|
);
|
|
CREATE INDEX IF NOT EXISTS jobs_type_created ON jobs (type, created DESC);
|
|
CREATE INDEX IF NOT EXISTS jobs_state ON jobs (state);
|
|
|
|
-- значения полей форм страниц
|
|
CREATE TABLE IF NOT EXISTS settings (
|
|
page TEXT PRIMARY KEY,
|
|
value TEXT NOT NULL
|
|
);
|
|
|
|
-- батч картинок: результат одного запуска text2img или одной загрузки файлов
|
|
CREATE TABLE IF NOT EXISTS ImageBatches (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
created INTEGER NOT NULL, -- мс
|
|
updated INTEGER NOT NULL,
|
|
sourceType TEXT NOT NULL, -- text | upload
|
|
sourceId INTEGER NOT NULL, -- ImageBatchTextSources.id | ImageBatchUploadSources.id (по sourceType)
|
|
state TEXT NOT NULL, -- draft | pending | done | error
|
|
error TEXT,
|
|
jobId TEXT, -- text: prompt_id последнего запуска в ComfyUI
|
|
seedUsed INTEGER, -- text: фактический seed последнего запуска
|
|
prompt TEXT, -- text: итоговый позитивный промпт последнего запуска
|
|
clonedFrom INTEGER REFERENCES ImageBatches(id) ON DELETE SET NULL
|
|
);
|
|
CREATE INDEX IF NOT EXISTS ImageBatches_created ON ImageBatches (created DESC);
|
|
|
|
-- пользовательский ввод text2img — всё, что нужно, чтобы повторить запуск
|
|
CREATE TABLE IF NOT EXISTS ImageBatchTextSources (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
shape TEXT NOT NULL,
|
|
colors TEXT NOT NULL,
|
|
template TEXT NOT NULL, -- как ввёл пользователь; пусто — шаблон по умолчанию
|
|
negative TEXT NOT NULL,
|
|
batchSize INTEGER NOT NULL,
|
|
seed TEXT NOT NULL -- как введено; пусто — случайный
|
|
);
|
|
|
|
-- загрузка файлов пользователем (один или несколько файлов за раз)
|
|
CREATE TABLE IF NOT EXISTS ImageBatchUploadSources (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
files TEXT NOT NULL -- JSON: исходные имена файлов
|
|
);
|
|
|
|
-- картинки батчей (сгенерированные и загруженные)
|
|
CREATE TABLE IF NOT EXISTS Images (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
batchId INTEGER NOT NULL REFERENCES ImageBatches(id) ON DELETE CASCADE,
|
|
filename TEXT NOT NULL,
|
|
subfolder TEXT NOT NULL,
|
|
type TEXT NOT NULL, -- input | output
|
|
UNIQUE (type, subfolder, filename)
|
|
);
|
|
CREATE INDEX IF NOT EXISTS Images_batchId ON Images (batchId);
|
|
|
|
-- проект: работа над одной картинкой из батча (из одной картинки — только один проект)
|
|
CREATE TABLE IF NOT EXISTS Projects (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
created INTEGER NOT NULL, -- мс
|
|
imageId INTEGER NOT NULL UNIQUE REFERENCES Images(id) ON DELETE CASCADE
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS meta (
|
|
key TEXT PRIMARY KEY,
|
|
value TEXT NOT NULL
|
|
);
|
|
`);
|
|
|
|
// Столбцы, добавленные позже: в существующих базах — ALTER TABLE.
|
|
function addColumns(table: string, columns: Record<string, string>) {
|
|
const have = new Set((db.prepare(`PRAGMA table_info(${table})`).all() as { name: string }[]).map(c => c.name));
|
|
for (const [name, def] of Object.entries(columns)) if (!have.has(name)) db.exec(`ALTER TABLE ${table} ADD COLUMN ${name} ${def}`);
|
|
}
|
|
// последняя очищенная картинка проекта (история очисток не хранится)
|
|
addColumns('Projects', {
|
|
clean: 'TEXT', // JSON FileRef последней очищенной картинки
|
|
cleanUpdated: 'INTEGER', // мс
|
|
cleanJobId: 'TEXT', // prompt_id идущей очистки
|
|
cleanError: 'TEXT', // ошибка последней очистки
|
|
});
|
|
// 3D-артефакты проекта (история не хранится): модель без текстур и текстурная группа (TRELLIS.2 или Paint).
|
|
// v2: прежние раздельные столбцы model*/texture*/trellis*/paint* убраны, 3D-результаты начаты с нуля.
|
|
if (!(db.prepare("SELECT 1 FROM meta WHERE key = 'projects.artifacts.v2'").get())) {
|
|
const have = new Set((db.prepare('PRAGMA table_info(Projects)').all() as { name: string }[]).map(c => c.name));
|
|
for (const c of ['model', 'modelPreview', 'modelUpdated', 'modelJobId', 'modelError', 'modelFaces',
|
|
'texture', 'textureUpdated', 'textureFaces', 'textureJobId', 'textureError',
|
|
'trellis', 'trellisUpdated', 'trellisFaces', 'trellisJobId', 'trellisError',
|
|
'paint', 'paintUpdated', 'paintFaces', 'paintJobId', 'paintError']) {
|
|
if (have.has(c)) db.exec(`ALTER TABLE Projects DROP COLUMN ${c}`);
|
|
}
|
|
db.exec(`DELETE FROM jobs WHERE type IN ('model', 'texture', 'trellis', 'paint')`);
|
|
db.exec(`DELETE FROM settings WHERE page IN ('trellis', 'paint')`);
|
|
db.exec(`INSERT INTO meta (key, value) VALUES ('projects.artifacts.v2', '1')`);
|
|
}
|
|
addColumns('Projects', {
|
|
model: 'TEXT', // JSON ModelArtifacts: модель без текстур
|
|
modelJobId: 'TEXT', // prompt_id идущей генерации
|
|
modelError: 'TEXT', // ошибка последней генерации
|
|
texture: 'TEXT', // JSON TextureArtifacts: текстурированная модель, текстуры, развёртка, виды
|
|
textureJobId: 'TEXT', // prompt_id идущего текстурирования
|
|
textureError: 'TEXT', // ошибка последнего текстурирования
|
|
});
|
|
// истории очисток, 3D-моделей и текстур не хранятся (результат — в проекте) — завершённые задачи удаляются
|
|
db.exec(`DELETE FROM jobs WHERE type IN ('cleanup', 'model', 'texture') AND state <> 'pending'`);
|
|
|
|
/** Несколько записей одной транзакцией. */
|
|
export function transaction<T>(fn: () => T): T {
|
|
db.exec('BEGIN');
|
|
try {
|
|
const res = fn();
|
|
db.exec('COMMIT');
|
|
return res;
|
|
} catch (e) {
|
|
db.exec('ROLLBACK');
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
// ---------- jobs ----------
|
|
|
|
interface JobRow {
|
|
id: string; type: string; created: number; state: string; error: string | null;
|
|
source: string | null; params: string; images: string; models: string;
|
|
}
|
|
|
|
function toJob(row: JobRow): Job {
|
|
return {
|
|
id: row.id, type: row.type, created: row.created, state: row.state, ...(row.error ? { error: row.error } : {}),
|
|
source: row.source ? JSON.parse(row.source) : null, params: JSON.parse(row.params),
|
|
images: JSON.parse(row.images), models: JSON.parse(row.models),
|
|
} as Job;
|
|
}
|
|
|
|
const jq = {
|
|
insert: db.prepare(`INSERT OR IGNORE INTO jobs (id, type, created, state, error, source, params, images, models)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`),
|
|
pending: db.prepare(`SELECT * FROM jobs WHERE state = 'pending'`),
|
|
finish: db.prepare('UPDATE jobs SET state = ?, error = ?, images = ?, models = ? WHERE id = ?'),
|
|
};
|
|
|
|
export function insertJob(j: Job) {
|
|
jq.insert.run(j.id, j.type, j.created, j.state, j.error ?? null, j.source ? JSON.stringify(j.source) : null,
|
|
JSON.stringify(j.params), JSON.stringify(j.images), JSON.stringify(j.models));
|
|
}
|
|
|
|
export function pendingJobs(): Job[] {
|
|
return (jq.pending.all() as unknown as JobRow[]).map(toJob);
|
|
}
|
|
|
|
export function finishJob(id: string, state: Exclude<JobState, 'pending'>, result: { error?: string; images?: FileRef[]; models?: FileRef[] }) {
|
|
jq.finish.run(state, result.error ?? null, JSON.stringify(result.images ?? []), JSON.stringify(result.models ?? []), id);
|
|
}
|
|
|
|
|
|
// ---------- settings, meta ----------
|
|
|
|
const sq = {
|
|
get: db.prepare('SELECT value FROM settings WHERE page = ?'),
|
|
put: db.prepare('INSERT INTO settings (page, value) VALUES (?, ?) ON CONFLICT(page) DO UPDATE SET value = excluded.value'),
|
|
getMeta: db.prepare('SELECT value FROM meta WHERE key = ?'),
|
|
setMeta: db.prepare('INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value'),
|
|
};
|
|
|
|
export function getSettings(page: SettingsPage): object {
|
|
const row = sq.get.get(page) as { value: string } | undefined;
|
|
return row ? JSON.parse(row.value) : {};
|
|
}
|
|
|
|
export function putSettings(page: SettingsPage, value: object) {
|
|
sq.put.run(page, JSON.stringify(value));
|
|
}
|
|
|
|
export function getMeta(key: string): string | null {
|
|
return (sq.getMeta.get(key) as { value: string } | undefined)?.value ?? null;
|
|
}
|
|
|
|
export function setMeta(key: string, value: string) {
|
|
sq.setMeta.run(key, value);
|
|
}
|
|
|
|
// ---------- ImageBatches + источники + Images ----------
|
|
|
|
interface BatchRow {
|
|
id: number; created: number; updated: number; sourceType: string; sourceId: number; state: string; error: string | null;
|
|
jobId: string | null; seedUsed: number | null; prompt: string | null; clonedFrom: number | null;
|
|
// из ImageBatchTextSources
|
|
shape: string | null; colors: string | null; template: string | null; negative: string | null; batchSize: number | null; seed: string | null;
|
|
// из ImageBatchUploadSources
|
|
files: string | null;
|
|
}
|
|
|
|
interface ImageRow { id: number; batchId: number; filename: string; subfolder: string; type: string; projectId: number | null }
|
|
|
|
/** Картинки с id и проектом (если из картинки создан проект). */
|
|
const SELECT_IMAGES = `
|
|
SELECT i.id, i.batchId, i.filename, i.subfolder, i.type, p.id AS projectId
|
|
FROM Images i LEFT JOIN Projects p ON p.imageId = i.id`;
|
|
|
|
const SELECT_BATCH = `
|
|
SELECT b.*, t.shape, t.colors, t.template, t.negative, t.batchSize, t.seed, u.files
|
|
FROM ImageBatches b
|
|
LEFT JOIN ImageBatchTextSources t ON b.sourceType = 'text' AND t.id = b.sourceId
|
|
LEFT JOIN ImageBatchUploadSources u ON b.sourceType = 'upload' AND u.id = b.sourceId`;
|
|
|
|
const bq = {
|
|
get: db.prepare(SELECT_BATCH + ' WHERE b.id = ?'),
|
|
list: db.prepare(SELECT_BATCH + ' ORDER BY b.created DESC, b.id DESC LIMIT ?'),
|
|
byJob: db.prepare('SELECT id FROM ImageBatches WHERE jobId = ?'),
|
|
insertBatch: db.prepare(`INSERT INTO ImageBatches (created, updated, sourceType, sourceId, state, seedUsed, prompt, clonedFrom)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)`),
|
|
insertText: db.prepare(`INSERT INTO ImageBatchTextSources (shape, colors, template, negative, batchSize, seed)
|
|
VALUES (?, ?, ?, ?, ?, ?)`),
|
|
updateText: db.prepare(`UPDATE ImageBatchTextSources SET shape = ?, colors = ?, template = ?, negative = ?, batchSize = ?, seed = ?
|
|
WHERE id = ?`),
|
|
insertUpload: db.prepare('INSERT INTO ImageBatchUploadSources (files) VALUES (?)'),
|
|
touch: db.prepare('UPDATE ImageBatches SET updated = ? WHERE id = ?'),
|
|
start: db.prepare(`UPDATE ImageBatches SET state = 'pending', error = NULL, jobId = ?, seedUsed = ?, prompt = ?, updated = ? WHERE id = ?`),
|
|
finish: db.prepare('UPDATE ImageBatches SET state = ?, error = ?, updated = ? WHERE id = ?'),
|
|
removeBatch: db.prepare('DELETE FROM ImageBatches WHERE id = ?'),
|
|
removeText: db.prepare('DELETE FROM ImageBatchTextSources WHERE id = ?'),
|
|
removeUpload: db.prepare('DELETE FROM ImageBatchUploadSources WHERE id = ?'),
|
|
images: db.prepare(SELECT_IMAGES + ' WHERE i.batchId = ? ORDER BY i.id'),
|
|
listImages: db.prepare(SELECT_IMAGES + `
|
|
WHERE i.batchId IN (SELECT id FROM ImageBatches ORDER BY created DESC, id DESC LIMIT ?) ORDER BY i.id`),
|
|
image: db.prepare(SELECT_IMAGES + ' WHERE i.id = ?'),
|
|
attach: db.prepare('INSERT OR IGNORE INTO Images (batchId, filename, subfolder, type) VALUES (?, ?, ?, ?)'),
|
|
imageBatch: db.prepare('SELECT batchId FROM Images WHERE type = ? AND subfolder = ? AND filename = ?'),
|
|
};
|
|
|
|
const ref = (i: ImageRow): BatchImage => ({
|
|
id: i.id, filename: i.filename, subfolder: i.subfolder, type: i.type, projectId: i.projectId,
|
|
});
|
|
|
|
function toBatch(row: BatchRow, images: BatchImage[]): ImageBatch {
|
|
const base = {
|
|
id: row.id, created: row.created, updated: row.updated, sourceId: row.sourceId, state: row.state as BatchState,
|
|
...(row.error ? { error: row.error } : {}), clonedFrom: row.clonedFrom, images,
|
|
};
|
|
if (row.sourceType === 'upload') {
|
|
return { ...base, sourceType: 'upload', source: { id: row.sourceId, files: row.files ? JSON.parse(row.files) : [] } };
|
|
}
|
|
return {
|
|
...base, sourceType: 'text', jobId: row.jobId, seedUsed: row.seedUsed, prompt: row.prompt ?? '',
|
|
source: {
|
|
id: row.sourceId,
|
|
input: { shape: row.shape ?? '', colors: row.colors ?? '', template: row.template ?? '', negative: row.negative ?? '',
|
|
batch: row.batchSize ?? 1, seed: row.seed ?? '' },
|
|
},
|
|
};
|
|
}
|
|
|
|
export function getBatch(id: number): ImageBatch | null {
|
|
const row = bq.get.get(id) as BatchRow | undefined;
|
|
return row ? toBatch(row, (bq.images.all(id) as unknown as ImageRow[]).map(ref)) : null;
|
|
}
|
|
|
|
export function listBatches(limit = 1000): ImageBatch[] {
|
|
const byBatch = new Map<number, BatchImage[]>();
|
|
for (const i of bq.listImages.all(limit) as unknown as ImageRow[]) byBatch.set(i.batchId, [...(byBatch.get(i.batchId) ?? []), ref(i)]);
|
|
return (bq.list.all(limit) as unknown as BatchRow[]).map(row => toBatch(row, byBatch.get(row.id) ?? []));
|
|
}
|
|
|
|
export function batchByJob(jobId: string): number | null {
|
|
return (bq.byJob.get(jobId) as { id: number } | undefined)?.id ?? null;
|
|
}
|
|
|
|
/** В каком батче картинка (или null). */
|
|
export function batchOfImage(i: FileRef): number | null {
|
|
return (bq.imageBatch.get(i.type, i.subfolder, i.filename) as { batchId: number } | undefined)?.batchId ?? null;
|
|
}
|
|
|
|
/** Новый text-батч с источником. Без transaction — вызывать внутри неё, если нужно вместе с другими записями. */
|
|
export function insertTextBatch(input: Text2ImgInput, o: { created?: number; state?: BatchState; clonedFrom?: number | null;
|
|
seedUsed?: number | null; prompt?: string | null } = {}): number {
|
|
const src = bq.insertText.run(input.shape, input.colors, input.template, input.negative, input.batch, input.seed);
|
|
const now = Date.now();
|
|
const res = bq.insertBatch.run(o.created ?? now, now, 'text', Number(src.lastInsertRowid), o.state ?? 'draft',
|
|
o.seedUsed ?? null, o.prompt ?? null, o.clonedFrom ?? null);
|
|
return Number(res.lastInsertRowid);
|
|
}
|
|
|
|
export function createTextBatch(input: Text2ImgInput, clonedFrom: number | null = null): number {
|
|
return transaction(() => insertTextBatch(input, { clonedFrom }));
|
|
}
|
|
|
|
/** Новый upload-батч с загруженными картинками (одна загрузка — один батч). */
|
|
export function createUploadBatch(originalNames: string[], images: FileRef[]): number {
|
|
return transaction(() => {
|
|
const src = bq.insertUpload.run(JSON.stringify(originalNames));
|
|
const now = Date.now();
|
|
const id = Number(bq.insertBatch.run(now, now, 'upload', Number(src.lastInsertRowid), 'done', null, null, null).lastInsertRowid);
|
|
attachImages(id, images);
|
|
return id;
|
|
});
|
|
}
|
|
|
|
export function updateTextInput(batch: ImageBatch, input: Text2ImgInput) {
|
|
transaction(() => {
|
|
bq.updateText.run(input.shape, input.colors, input.template, input.negative, input.batch, input.seed, batch.sourceId);
|
|
bq.touch.run(Date.now(), batch.id);
|
|
});
|
|
}
|
|
|
|
export function startBatch(id: number, jobId: string, seedUsed: number, prompt: string) {
|
|
bq.start.run(jobId, seedUsed, prompt, Date.now(), id);
|
|
}
|
|
|
|
/** Прикрепить картинки к батчу (без своей транзакции). */
|
|
export function attachImages(id: number, images: FileRef[]) {
|
|
for (const i of images) bq.attach.run(id, i.filename, i.subfolder, i.type);
|
|
}
|
|
|
|
/** Завершение запуска: картинки к батчу + состояние (без своей транзакции — трекер вызывает внутри своей). */
|
|
export function finishBatch(id: number, state: 'done' | 'error', images: FileRef[], error?: string) {
|
|
attachImages(id, images);
|
|
bq.finish.run(state, error ?? null, Date.now(), id);
|
|
}
|
|
|
|
export function deleteBatch(b: ImageBatch) {
|
|
transaction(() => {
|
|
bq.removeBatch.run(b.id);
|
|
(b.sourceType === 'text' ? bq.removeText : bq.removeUpload).run(b.sourceId);
|
|
});
|
|
}
|
|
|
|
// ---------- Projects ----------
|
|
|
|
const SELECT_PROJECT = `
|
|
SELECT p.id, p.created, p.clean, p.cleanUpdated, p.cleanJobId, p.cleanError,
|
|
p.model, p.modelJobId, p.modelError, p.texture, p.textureJobId, p.textureError,
|
|
i.id AS imageId, i.batchId, i.filename, i.subfolder, i.type, b.sourceType
|
|
FROM Projects p JOIN Images i ON i.id = p.imageId JOIN ImageBatches b ON b.id = i.batchId`;
|
|
|
|
const pq = {
|
|
insert: db.prepare('INSERT OR IGNORE INTO Projects (created, imageId) VALUES (?, ?)'),
|
|
byImage: db.prepare('SELECT id FROM Projects WHERE imageId = ?'),
|
|
get: db.prepare(SELECT_PROJECT + ' WHERE p.id = ?'),
|
|
list: db.prepare(SELECT_PROJECT + ' ORDER BY p.created DESC, p.id DESC LIMIT ?'),
|
|
byCleanJob: db.prepare('SELECT id FROM Projects WHERE cleanJobId = ?'),
|
|
startClean: db.prepare('UPDATE Projects SET cleanJobId = ?, cleanError = NULL WHERE id = ?'),
|
|
finishClean: db.prepare('UPDATE Projects SET clean = COALESCE(?, clean), cleanUpdated = ?, cleanError = ?, cleanJobId = NULL WHERE id = ?'),
|
|
clearClean: db.prepare('UPDATE Projects SET clean = NULL, cleanUpdated = NULL, cleanError = NULL WHERE id = ?'),
|
|
byModelJob: db.prepare('SELECT id FROM Projects WHERE modelJobId = ?'),
|
|
startModel: db.prepare('UPDATE Projects SET modelJobId = ?, modelError = NULL WHERE id = ?'),
|
|
// новая модель заменяет прежнюю вместе с текстурами (они от прежней модели); при ошибке всё остаётся
|
|
finishModel: db.prepare(`UPDATE Projects SET model = COALESCE(?1, model),
|
|
texture = CASE WHEN ?1 IS NULL THEN texture ELSE ?2 END,
|
|
modelError = ?3, modelJobId = NULL WHERE id = ?4`),
|
|
byTextureJob: db.prepare('SELECT id FROM Projects WHERE textureJobId = ?'),
|
|
startTexture: db.prepare('UPDATE Projects SET textureJobId = ?, textureError = NULL WHERE id = ?'),
|
|
finishTexture: db.prepare('UPDATE Projects SET texture = COALESCE(?, texture), textureError = ?, textureJobId = NULL WHERE id = ?'),
|
|
clearModel: db.prepare('UPDATE Projects SET model = NULL, modelError = NULL, texture = NULL, textureError = NULL WHERE id = ?'),
|
|
clearTexture: db.prepare('UPDATE Projects SET texture = NULL, textureError = NULL WHERE id = ?'),
|
|
};
|
|
|
|
/** Генерация 3D-модели проекта поставлена в очередь. */
|
|
export function startProjectModel(id: number, jobId: string) {
|
|
pq.startModel.run(jobId, id);
|
|
}
|
|
|
|
export function projectByModelJob(jobId: string): number | null {
|
|
return (pq.byModelJob.get(jobId) as { id: number } | undefined)?.id ?? null;
|
|
}
|
|
|
|
/**
|
|
* Генерация завершена: новая модель заменяет прежнюю, прежние текстуры убираются (TRELLIS.2 сразу даёт свои).
|
|
* При ошибке (model = null) всё остаётся как было.
|
|
*/
|
|
export function finishProjectModel(id: number, model: ModelArtifacts | null, texture: TextureArtifacts | null, error?: string) {
|
|
pq.finishModel.run(model ? JSON.stringify(model) : null, texture ? JSON.stringify(texture) : null, error ?? null, id);
|
|
}
|
|
|
|
/** Текстурирование проекта поставлено в очередь. */
|
|
export function startProjectTexture(id: number, jobId: string) {
|
|
pq.startTexture.run(jobId, id);
|
|
}
|
|
|
|
export function projectByTextureJob(jobId: string): number | null {
|
|
return (pq.byTextureJob.get(jobId) as { id: number } | undefined)?.id ?? null;
|
|
}
|
|
|
|
/** Текстурирование завершено: новый результат заменяет прежний (при ошибке прежний остаётся). */
|
|
export function finishProjectTexture(id: number, texture: TextureArtifacts | null, error?: string) {
|
|
pq.finishTexture.run(texture ? JSON.stringify(texture) : null, error ?? null, id);
|
|
}
|
|
|
|
/** Убрать модель из проекта вместе с текстурами — они сделаны для неё (файлы в ComfyUI/output остаются). */
|
|
export function clearProjectModel(id: number) {
|
|
pq.clearModel.run(id);
|
|
}
|
|
|
|
/** Убрать текстурную группу (файлы в ComfyUI/output остаются). */
|
|
export function clearProjectTexture(id: number) {
|
|
pq.clearTexture.run(id);
|
|
}
|
|
|
|
/** Убрать очищенную картинку из проекта (файл в ComfyUI/output остаётся). */
|
|
export function clearProjectClean(id: number) {
|
|
pq.clearClean.run(id);
|
|
}
|
|
|
|
interface ProjectRow {
|
|
id: number; created: number; clean: string | null; cleanUpdated: number | null; cleanJobId: string | null; cleanError: string | null;
|
|
model: string | null; modelJobId: string | null; modelError: string | null;
|
|
texture: string | null; textureJobId: string | null; textureError: string | null;
|
|
imageId: number; batchId: number; filename: string; subfolder: string; type: string; sourceType: string;
|
|
}
|
|
|
|
const json = (s: string | null) => (s ? JSON.parse(s) : null);
|
|
|
|
function toProject(r: ProjectRow): Project {
|
|
return {
|
|
id: r.id, created: r.created, batchId: r.batchId, imageSource: r.sourceType === 'upload' ? 'upload' : 'text',
|
|
image: { id: r.imageId, filename: r.filename, subfolder: r.subfolder, type: r.type, projectId: r.id },
|
|
clean: json(r.clean), cleanUpdated: r.cleanUpdated,
|
|
cleanJobId: r.cleanJobId, ...(r.cleanError ? { cleanError: r.cleanError } : {}),
|
|
model: json(r.model), modelJobId: r.modelJobId, ...(r.modelError ? { modelError: r.modelError } : {}),
|
|
texture: json(r.texture), textureJobId: r.textureJobId, ...(r.textureError ? { textureError: r.textureError } : {}),
|
|
};
|
|
}
|
|
|
|
export function listProjects(limit = 1000): Project[] {
|
|
return (pq.list.all(limit) as unknown as ProjectRow[]).map(toProject);
|
|
}
|
|
|
|
/** Очистка исходника проекта поставлена в очередь. */
|
|
export function startProjectClean(id: number, jobId: string) {
|
|
pq.startClean.run(jobId, id);
|
|
}
|
|
|
|
export function projectByCleanJob(jobId: string): number | null {
|
|
return (pq.byCleanJob.get(jobId) as { id: number } | undefined)?.id ?? null;
|
|
}
|
|
|
|
/** Очистка завершена: результат заменяет прежнюю очищенную картинку (при ошибке прежняя остаётся). */
|
|
export function finishProjectClean(id: number, clean: FileRef | null, error?: string) {
|
|
pq.finishClean.run(clean ? JSON.stringify(clean) : null, Date.now(), error ?? null, id);
|
|
}
|
|
|
|
export function getImage(id: number): (BatchImage & { batchId: number }) | null {
|
|
const row = bq.image.get(id) as ImageRow | undefined;
|
|
return row ? { ...ref(row), batchId: row.batchId } : null;
|
|
}
|
|
|
|
/** Проект из картинки: из одной картинки — только один проект; если уже есть, возвращается он. */
|
|
export function projectForImage(imageId: number): number {
|
|
pq.insert.run(Date.now(), imageId);
|
|
return (pq.byImage.get(imageId) as { id: number }).id;
|
|
}
|
|
|
|
export function getProject(id: number): Project | null {
|
|
const row = pq.get.get(id) as ProjectRow | undefined;
|
|
return row ? toProject(row) : null;
|
|
}
|
|
|
|
/** Удаление задачи (история очисток не хранится). */
|
|
export function deleteJob(id: string) {
|
|
db.prepare('DELETE FROM jobs WHERE id = ?').run(id);
|
|
}
|