@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/storage/workspaceAssetStore.js

@@ -0,0 +1,496 @@
+import { normalizeCanonicalAssetKind } from '../utils/canonicalAssetKind.js';
+function normalizeId(raw, fallback = '') {
+    return String(raw || '').trim() || fallback;
+}
+function normalizeNullable(raw) {
+    const value = String(raw || '').trim();
+    return value ? value : null;
+}
+function normalizeWorkspaceId(raw) {
+    return normalizeId(raw, 'default');
+}
+function mapAssetRow(row) {
+    const kind = normalizeCanonicalAssetKind({
+        kind: String(row.kind || 'file'),
+        storageKey: String(row.storage_key || ''),
+        originalFilename: String(row.original_filename || ''),
+        mimeType: String(row.mime_type || 'application/octet-stream')
+    });
+    return {
+        assetId: String(row.asset_id || ''),
+        tenantId: String(row.tenant_id || 'default'),
+        workspaceId: String(row.workspace_id || 'default'),
+        kind,
+        logicalName: row.logical_name == null ? null : String(row.logical_name),
+        originalFilename: String(row.original_filename || ''),
+        mimeType: String(row.mime_type || 'application/octet-stream'),
+        storageProvider: String(row.storage_provider || 'local') === 'r2'
+            ? 'r2'
+            : String(row.storage_provider || 'local') === 'external'
+                ? 'external'
+                : 'local',
+        storageKey: String(row.storage_key || ''),
+        contentSha256: String(row.content_sha256 || ''),
+        sizeBytes: Number(row.size_bytes || 0),
+        documentId: row.document_id == null ? null : String(row.document_id),
+        referenceNumber: row.reference_number == null ? null : Number(row.reference_number),
+        version: row.version == null ? null : Number(row.version),
+        isLatest: Number(row.is_latest || 0) === 1,
+        scanStatus: String(row.scan_status || 'clean'),
+        scanEngine: row.scan_engine == null ? null : String(row.scan_engine),
+        scanDetails: row.scan_details == null ? null : String(row.scan_details),
+        createdByUserId: row.created_by_user_id == null ? null : String(row.created_by_user_id),
+        createdAt: String(row.created_at || ''),
+        updatedAt: String(row.updated_at || ''),
+        deletedAt: row.deleted_at == null ? null : String(row.deleted_at),
+        purgeAfter: row.purge_after == null ? null : String(row.purge_after)
+    };
+}
+function mapLinkRow(row) {
+    return {
+        tenantId: String(row.tenant_id || 'default'),
+        workspaceId: String(row.workspace_id || 'default'),
+        assetId: String(row.asset_id || ''),
+        taskId: String(row.task_id || ''),
+        role: String(row.role || 'attachment'),
+        displayName: row.display_name == null ? null : String(row.display_name),
+        sortOrder: row.sort_order == null ? null : Number(row.sort_order),
+        createdAt: String(row.created_at || ''),
+        updatedAt: String(row.updated_at || ''),
+        deletedAt: row.deleted_at == null ? null : String(row.deleted_at)
+    };
+}
+function normalizeReferenceNumber(raw) {
+    const numeric = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isFinite(numeric))
+        return null;
+    const normalized = Math.floor(numeric);
+    return normalized > 0 ? normalized : null;
+}
+function usesReadableAssetReference(kind) {
+    return kind === 'document' || kind === 'image';
+}
+export class WorkspaceAssetStore {
+    db;
+    tenantId;
+    constructor(db, tenantId) {
+        this.db = db;
+        this.tenantId = tenantId;
+    }
+    normalizePersistedAsset(entry) {
+        const normalizedKind = normalizeCanonicalAssetKind({
+            kind: entry.kind,
+            storageKey: entry.storageKey,
+            originalFilename: entry.originalFilename,
+            mimeType: entry.mimeType
+        });
+        if (normalizedKind === entry.kind)
+            return entry;
+        this.db.prepare(`
+            UPDATE workspace_assets
+            SET kind = ?, document_id = NULL, reference_number = NULL, version = NULL
+            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+        `).run(normalizedKind, this.tenantId, entry.workspaceId, entry.assetId);
+        return {
+            ...entry,
+            kind: normalizedKind,
+            documentId: null,
+            referenceNumber: null,
+            version: null
+        };
+    }
+    get(assetIdRaw, workspaceIdRaw) {
+        const assetId = normalizeId(assetIdRaw);
+        if (!assetId)
+            return null;
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const row = this.db.prepare(`
+            SELECT *
+            FROM workspace_assets
+            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+            LIMIT 1
+        `).get(this.tenantId, workspaceId, assetId);
+        return row ? this.normalizePersistedAsset(mapAssetRow(row)) : null;
+    }
+    getByStorageKey(storageKeyRaw, workspaceIdRaw) {
+        const storageKey = normalizeId(storageKeyRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!storageKey)
+            return null;
+        const row = this.db.prepare(`
+            SELECT *
+            FROM workspace_assets
+            WHERE tenant_id = ? AND workspace_id = ? AND storage_key = ?
+            ORDER BY updated_at DESC, asset_id ASC
+            LIMIT 1
+        `).get(this.tenantId, workspaceId, storageKey);
+        return row ? this.normalizePersistedAsset(mapAssetRow(row)) : null;
+    }
+    getByKindAndReferenceNumber(workspaceIdRaw, kind, referenceNumberRaw) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const referenceNumber = normalizeReferenceNumber(referenceNumberRaw);
+        if (!referenceNumber || !usesReadableAssetReference(kind))
+            return null;
+        const row = this.db.prepare(`
+            SELECT *
+            FROM workspace_assets
+            WHERE tenant_id = ? AND workspace_id = ? AND kind = ? AND reference_number = ?
+            LIMIT 1
+        `).get(this.tenantId, workspaceId, kind, referenceNumber);
+        return row ? this.normalizePersistedAsset(mapAssetRow(row)) : null;
+    }
+    upsertAsset(input) {
+        const normalizedKind = normalizeCanonicalAssetKind({
+            kind: input.kind,
+            storageKey: input.storageKey,
+            originalFilename: input.originalFilename,
+            mimeType: input.mimeType
+        });
+        const assetId = normalizeId(input.assetId);
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const nowIso = new Date().toISOString();
+        const createdAt = normalizeId(input.createdAt, nowIso);
+        const updatedAt = normalizeId(input.updatedAt, createdAt);
+        const existing = this.get(assetId, workspaceId);
+        const incomingReferenceNumber = normalizeReferenceNumber(input.referenceNumber);
+        let referenceNumber = usesReadableAssetReference(normalizedKind)
+            ? (existing?.referenceNumber
+                ? (input.allowReferenceNumberReassignment === true && incomingReferenceNumber
+                    ? incomingReferenceNumber
+                    : existing.referenceNumber)
+                : (incomingReferenceNumber
+                    || this.reserveAssetReferenceNumber(workspaceId, normalizedKind)))
+            : null;
+        if (usesReadableAssetReference(normalizedKind) && referenceNumber) {
+            const conflicting = this.getByKindAndReferenceNumber(workspaceId, normalizedKind, referenceNumber);
+            if (conflicting && conflicting.assetId !== assetId) {
+                if (existing?.referenceNumber && existing.referenceNumber !== conflicting.referenceNumber) {
+                    referenceNumber = existing.referenceNumber;
+                }
+                else {
+                    referenceNumber = this.findNextAvailableReadableAssetReferenceNumber(workspaceId, normalizedKind);
+                }
+            }
+        }
+        const persistAsset = (resolvedReferenceNumber) => {
+            this.db.prepare(`
+            INSERT INTO workspace_assets (
+                asset_id,
+                tenant_id,
+                workspace_id,
+                kind,
+                logical_name,
+                original_filename,
+                mime_type,
+                storage_provider,
+                storage_key,
+                content_sha256,
+                size_bytes,
+                document_id,
+                reference_number,
+                version,
+                is_latest,
+                scan_status,
+                scan_engine,
+                scan_details,
+                created_by_user_id,
+                created_at,
+                updated_at,
+                deleted_at,
+                purge_after
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(asset_id) DO UPDATE SET
+                workspace_id = excluded.workspace_id,
+                kind = excluded.kind,
+                logical_name = excluded.logical_name,
+                original_filename = excluded.original_filename,
+                mime_type = excluded.mime_type,
+                storage_provider = excluded.storage_provider,
+                storage_key = excluded.storage_key,
+                content_sha256 = excluded.content_sha256,
+                size_bytes = excluded.size_bytes,
+                document_id = excluded.document_id,
+                reference_number = excluded.reference_number,
+                version = excluded.version,
+                is_latest = excluded.is_latest,
+                scan_status = excluded.scan_status,
+                scan_engine = excluded.scan_engine,
+                scan_details = excluded.scan_details,
+                created_by_user_id = excluded.created_by_user_id,
+                updated_at = excluded.updated_at,
+                deleted_at = excluded.deleted_at,
+                purge_after = excluded.purge_after
+        `).run(assetId, this.tenantId, workspaceId, normalizedKind, normalizeNullable(input.logicalName), normalizeId(input.originalFilename), normalizeId(input.mimeType, 'application/octet-stream'), input.storageProvider === 'r2'
+                ? 'r2'
+                : input.storageProvider === 'external'
+                    ? 'external'
+                    : 'local', normalizeId(input.storageKey), normalizeId(input.contentSha256), Math.max(0, Math.floor(Number(input.sizeBytes || 0))), normalizedKind === 'document' ? normalizeNullable(input.documentId) : null, resolvedReferenceNumber, normalizedKind === 'document' && input.version != null ? Math.max(1, Math.floor(Number(input.version))) : null, input.isLatest === false ? 0 : 1, normalizeId(input.scanStatus, 'clean'), normalizeNullable(input.scanEngine), normalizeNullable(input.scanDetails), normalizeNullable(input.createdByUserId), createdAt, updatedAt, normalizeNullable(input.deletedAt), normalizeNullable(input.purgeAfter));
+        };
+        try {
+            persistAsset(referenceNumber);
+        }
+        catch (error) {
+            const message = String(error?.message || error || '');
+            const isReadableReferenceConflict = usesReadableAssetReference(normalizedKind)
+                && referenceNumber != null
+                && message.includes('workspace_assets')
+                && message.includes('reference_number');
+            if (!isReadableReferenceConflict) {
+                throw error;
+            }
+            const failedReferenceNumber = Number(referenceNumber);
+            const nextAvailableReferenceNumber = this.findNextAvailableReadableAssetReferenceNumber(workspaceId, normalizedKind);
+            const retryReferenceNumber = existing?.referenceNumber
+                && (!this.getByKindAndReferenceNumber(workspaceId, normalizedKind, existing.referenceNumber)
+                    || this.getByKindAndReferenceNumber(workspaceId, normalizedKind, existing.referenceNumber)?.assetId === assetId)
+                ? existing.referenceNumber
+                : Math.max(nextAvailableReferenceNumber, failedReferenceNumber + 1);
+            referenceNumber = retryReferenceNumber;
+            persistAsset(referenceNumber);
+        }
+        return this.get(assetId, workspaceId);
+    }
+    reserveAssetReferenceNumber(workspaceIdRaw, kind) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!usesReadableAssetReference(kind)) {
+            throw new Error(`Readable references are not supported for asset kind "${kind}"`);
+        }
+        const sequenceTable = kind === 'image'
+            ? 'workspace_image_reference_sequences'
+            : 'workspace_document_reference_sequences';
+        const row = this.db.prepare(`
+            INSERT INTO ${sequenceTable} (tenant_id, workspace_id, next_reference_number)
+            VALUES (?, ?, 1)
+            ON CONFLICT (tenant_id, workspace_id) DO UPDATE SET
+                next_reference_number = ${sequenceTable}.next_reference_number + 1
+            RETURNING next_reference_number
+        `).get(this.tenantId, workspaceId);
+        const referenceNumber = normalizeReferenceNumber(row?.next_reference_number);
+        if (!referenceNumber) {
+            throw new Error(`Failed to allocate ${kind} reference number`);
+        }
+        const conflicting = this.getByKindAndReferenceNumber(workspaceId, kind, referenceNumber);
+        if (!conflicting) {
+            return referenceNumber;
+        }
+        const nextAvailable = this.findNextAvailableReadableAssetReferenceNumber(workspaceId, kind);
+        if (nextAvailable > referenceNumber) {
+            this.db.prepare(`
+                UPDATE ${sequenceTable}
+                SET next_reference_number = ?
+                WHERE tenant_id = ? AND workspace_id = ?
+            `).run(nextAvailable, this.tenantId, workspaceId);
+        }
+        return nextAvailable;
+    }
+    findNextAvailableReadableAssetReferenceNumber(workspaceIdRaw, kind) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const row = this.db.prepare(`
+            SELECT COALESCE(MAX(reference_number), 0) AS max_reference
+            FROM workspace_assets
+            WHERE tenant_id = ? AND workspace_id = ? AND kind = ?
+        `).get(this.tenantId, workspaceId, kind);
+        const next = Math.max(0, Number(row?.max_reference || 0)) + 1;
+        return next;
+    }
+    listByWorkspace(workspaceIdRaw, options) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const includeDeleted = options?.includeDeleted === true;
+        const kind = options?.kind ? String(options.kind) : '';
+        const limit = Number.isFinite(options?.limit) ? Math.max(1, Math.floor(Number(options?.limit))) : 500;
+        const offset = Number.isFinite(options?.offset) ? Math.max(0, Math.floor(Number(options?.offset))) : 0;
+        const clauses = ['tenant_id = ?', 'workspace_id = ?'];
+        const params = [this.tenantId, workspaceId];
+        if (!includeDeleted)
+            clauses.push('deleted_at IS NULL');
+        if (kind) {
+            clauses.push('kind = ?');
+            params.push(kind);
+        }
+        params.push(limit, offset);
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM workspace_assets
+            WHERE ${clauses.join(' AND ')}
+            ORDER BY updated_at DESC, asset_id ASC
+            LIMIT ? OFFSET ?
+        `).all(...params);
+        return rows.map(mapAssetRow);
+    }
+    listAllByWorkspace(workspaceIdRaw, options) {
+        const pageSize = Math.min(1000, Math.max(100, Number.isFinite(options?.pageSize) ? Number(options?.pageSize) : 1000));
+        const all = [];
+        let offset = 0;
+        for (;;) {
+            const page = this.listByWorkspace(workspaceIdRaw, { ...options, limit: pageSize, offset });
+            all.push(...page);
+            if (page.length < pageSize)
+                break;
+            offset += pageSize;
+        }
+        return all;
+    }
+    listAll(options) {
+        const includeDeleted = options?.includeDeleted === true;
+        const kind = options?.kind ? String(options.kind) : '';
+        const limit = Number.isFinite(options?.limit) ? Math.max(1, Math.floor(Number(options?.limit))) : 500;
+        const clauses = ['tenant_id = ?'];
+        const params = [this.tenantId];
+        if (!includeDeleted)
+            clauses.push('deleted_at IS NULL');
+        if (kind) {
+            clauses.push('kind = ?');
+            params.push(kind);
+        }
+        params.push(limit);
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM workspace_assets
+            WHERE ${clauses.join(' AND ')}
+            ORDER BY updated_at DESC, asset_id ASC
+            LIMIT ?
+        `).all(...params);
+        return rows.map(mapAssetRow);
+    }
+    listQuarantined(limitRaw = 200) {
+        const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.floor(Number(limitRaw))) : 200;
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM workspace_assets
+            WHERE tenant_id = ?
+              AND scan_status = 'infected'
+              AND deleted_at IS NULL
+            ORDER BY updated_at DESC, asset_id ASC
+            LIMIT ?
+        `).all(this.tenantId, limit);
+        return rows.map(mapAssetRow);
+    }
+    listPurgeCandidates(now = new Date(), limitRaw = 500) {
+        const nowIso = now.toISOString();
+        const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.floor(Number(limitRaw))) : 500;
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM workspace_assets
+            WHERE tenant_id = ?
+              AND deleted_at IS NOT NULL
+              AND purge_after IS NOT NULL
+              AND purge_after <= ?
+            ORDER BY purge_after ASC, updated_at ASC, asset_id ASC
+            LIMIT ?
+        `).all(this.tenantId, nowIso, limit);
+        return rows.map(mapAssetRow);
+    }
+    markDeleted(assetIdRaw, workspaceIdRaw, deletedAt, purgeAfter) {
+        const assetId = normalizeId(assetIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!assetId)
+            return null;
+        const nowIso = normalizeId(deletedAt, new Date().toISOString());
+        this.db.prepare(`
+            UPDATE workspace_assets
+            SET deleted_at = ?, purge_after = ?, updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+        `).run(nowIso, normalizeNullable(purgeAfter), nowIso, this.tenantId, workspaceId, assetId);
+        return this.get(assetId, workspaceId);
+    }
+    remove(assetIdRaw, workspaceIdRaw) {
+        const assetId = normalizeId(assetIdRaw);
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        if (!assetId)
+            return false;
+        this.db.prepare(`
+            DELETE FROM workspace_asset_links
+            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+        `).run(this.tenantId, workspaceId, assetId);
+        const result = this.db.prepare(`
+            DELETE FROM workspace_assets
+            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ?
+        `).run(this.tenantId, workspaceId, assetId);
+        return Number(result?.changes || 0) > 0;
+    }
+    upsertLink(input) {
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const assetId = normalizeId(input.assetId);
+        const taskId = normalizeId(input.taskId);
+        const role = normalizeId(input.role, 'attachment');
+        const createdAt = normalizeId(input.createdAt, new Date().toISOString());
+        const updatedAt = normalizeId(input.updatedAt, createdAt);
+        this.db.prepare(`
+            INSERT INTO workspace_asset_links (
+                tenant_id,
+                workspace_id,
+                asset_id,
+                task_id,
+                role,
+                display_name,
+                sort_order,
+                created_at,
+                updated_at,
+                deleted_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(tenant_id, workspace_id, asset_id, task_id, role) DO UPDATE SET
+                display_name = excluded.display_name,
+                sort_order = excluded.sort_order,
+                updated_at = excluded.updated_at,
+                deleted_at = excluded.deleted_at
+        `).run(this.tenantId, workspaceId, assetId, taskId, role, normalizeNullable(input.displayName), input.sortOrder == null ? null : Math.floor(Number(input.sortOrder)), createdAt, updatedAt, normalizeNullable(input.deletedAt));
+        return this.listLinksForAsset(assetId, workspaceId, { includeDeleted: true })
+            .find((entry) => entry.taskId === taskId && entry.role === role);
+    }
+    listLinksForTask(taskIdRaw, workspaceIdRaw, options) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const taskId = normalizeId(taskIdRaw);
+        if (!taskId)
+            return [];
+        const includeDeleted = options?.includeDeleted === true;
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM workspace_asset_links
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND task_id = ?
+              ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+            ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC, asset_id ASC
+        `).all(this.tenantId, workspaceId, taskId);
+        return rows.map(mapLinkRow);
+    }
+    listLinksForAsset(assetIdRaw, workspaceIdRaw, options) {
+        const workspaceId = normalizeWorkspaceId(workspaceIdRaw);
+        const assetId = normalizeId(assetIdRaw);
+        if (!assetId)
+            return [];
+        const includeDeleted = options?.includeDeleted === true;
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM workspace_asset_links
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND asset_id = ?
+              ${includeDeleted ? '' : 'AND deleted_at IS NULL'}
+            ORDER BY COALESCE(sort_order, 2147483647) ASC, created_at ASC, task_id ASC
+        `).all(this.tenantId, workspaceId, assetId);
+        return rows.map(mapLinkRow);
+    }
+    deleteLink(input) {
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const assetId = normalizeId(input.assetId);
+        const taskId = normalizeId(input.taskId);
+        const role = normalizeId(input.role);
+        if (!assetId || !taskId || !role)
+            return false;
+        if (input.hardDelete) {
+            const result = this.db.prepare(`
+                DELETE FROM workspace_asset_links
+                WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
+            `).run(this.tenantId, workspaceId, assetId, taskId, role);
+            return Number(result?.changes || 0) > 0;
+        }
+        const nowIso = new Date().toISOString();
+        const result = this.db.prepare(`
+            UPDATE workspace_asset_links
+            SET deleted_at = ?, updated_at = ?
+            WHERE tenant_id = ? AND workspace_id = ? AND asset_id = ? AND task_id = ? AND role = ?
+        `).run(nowIso, nowIso, this.tenantId, workspaceId, assetId, taskId, role);
+        return Number(result?.changes || 0) > 0;
+    }
+}

package/dist/storage/workspaceAssetStore.test.d.ts

@@ -0,0 +1 @@
+export {};