@taskforcehq/taskforce 0.3.311 → 0.3.313

package/dist/storage/workspaceAssetStore.test.js

@@ -1,588 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { createDatabaseAdapter } from './createDatabaseAdapter.js';
-import { ensureDocumentReferenceSchema, ensureTaskAssetsSchema, ensureWorkspaceAssetsSchema } from '../migrations/taskSchemaMigrations.js';
-import { WorkspaceAssetStore } from './workspaceAssetStore.js';
-function makeStore() {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-workspace-assets-'));
-    const dbPath = path.join(root, 'taskforce.db');
-    const db = createDatabaseAdapter({ sqliteDbPath: dbPath });
-    ensureTaskAssetsSchema(db);
-    ensureWorkspaceAssetsSchema(db);
-    ensureDocumentReferenceSchema(db);
-    const store = new WorkspaceAssetStore(db, 'default');
-    return {
-        root,
-        db,
-        store,
-        cleanup() {
-            db.close();
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    };
-}
-function makeLegacyLinkStore() {
-    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-workspace-assets-legacy-'));
-    const dbPath = path.join(root, 'taskforce.db');
-    const db = createDatabaseAdapter({ sqliteDbPath: dbPath });
-    ensureTaskAssetsSchema(db);
-    ensureWorkspaceAssetsSchema(db);
-    ensureDocumentReferenceSchema(db);
-    db.exec(`DROP TABLE IF EXISTS workspace_asset_links`);
-    db.exec(`
-        CREATE TABLE IF NOT EXISTS workspace_asset_links (
-            tenant_id TEXT NOT NULL DEFAULT 'default',
-            workspace_id TEXT NOT NULL,
-            asset_id TEXT NOT NULL,
-            task_id TEXT NOT NULL,
-            role TEXT NOT NULL,
-            display_name TEXT,
-            sort_order INTEGER,
-            created_at TEXT NOT NULL,
-            updated_at TEXT NOT NULL,
-            deleted_at TEXT,
-            PRIMARY KEY (tenant_id, workspace_id, asset_id, task_id, role)
-        );
-    `);
-    const store = new WorkspaceAssetStore(db, 'default');
-    return {
-        root,
-        db,
-        store,
-        cleanup() {
-            db.close();
-            fs.rmSync(root, { recursive: true, force: true });
-        }
-    };
-}
-describe('WorkspaceAssetStore', () => {
-    const cleanups = [];
-    afterEach(() => {
-        while (cleanups.length > 0) {
-            const cleanup = cleanups.pop();
-            cleanup?.();
-        }
-    });
-    it('upserts and reads canonical assets by asset id', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        const created = ctx.store.upsertAsset({
-            assetId: 'asset-1',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            logicalName: 'Spec',
-            originalFilename: 'spec.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/asset-1-spec.md',
-            contentSha256: 'sha-123',
-            sizeBytes: 128,
-            documentId: 'doc-1',
-            version: 1,
-            createdByUserId: 'user-1',
-            scanStatus: 'clean'
-        });
-        expect(created.assetId).toBe('asset-1');
-        expect(created.workspaceId).toBe('workspace-1');
-        expect(created.kind).toBe('document');
-        expect(created.storageKey).toContain('workspaces/workspace-1/assets/documents');
-        expect(created.referenceNumber).toBe(1);
-        const fetched = ctx.store.get('asset-1', 'workspace-1');
-        expect(fetched).toMatchObject({
-            assetId: 'asset-1',
-            documentId: 'doc-1',
-            version: 1,
-            isLatest: true,
-            referenceNumber: 1
-        });
-    });
-    it('supports legacy workspace asset links without target_type', () => {
-        const ctx = makeLegacyLinkStore();
-        cleanups.push(() => ctx.cleanup());
-        const now = new Date().toISOString();
-        ctx.store.upsertAsset({
-            assetId: 'asset-legacy-1',
-            workspaceId: 'workspace-1',
-            kind: 'file',
-            originalFilename: 'legacy.pdf',
-            mimeType: 'application/pdf',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/files/asset-legacy-1-legacy.pdf',
-            contentSha256: 'sha-legacy',
-            sizeBytes: 42,
-            createdAt: now,
-            updatedAt: now
-        });
-        const created = ctx.store.upsertLink({
-            workspaceId: 'workspace-1',
-            assetId: 'asset-legacy-1',
-            taskId: 'task-1',
-            role: 'attachment',
-            displayName: 'Legacy attachment',
-            createdAt: now,
-            updatedAt: now
-        });
-        expect(created.targetType).toBe('task');
-        expect(created.targetId).toBe('task-1');
-        expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toEqual([
-            expect.objectContaining({
-                assetId: 'asset-legacy-1',
-                targetType: 'task',
-                targetId: 'task-1',
-                role: 'attachment'
-            })
-        ]);
-        expect(ctx.store.deleteLink({
-            workspaceId: 'workspace-1',
-            assetId: 'asset-legacy-1',
-            taskId: 'task-1',
-            role: 'attachment'
-        })).toBe(true);
-        expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toEqual([]);
-    });
-    it('assigns sequential document reference numbers per workspace', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        const first = ctx.store.upsertAsset({
-            assetId: 'asset-doc-1',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'alpha.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-1-alpha.md',
-            contentSha256: 'sha-alpha',
-            sizeBytes: 10
-        });
-        const second = ctx.store.upsertAsset({
-            assetId: 'asset-doc-2',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'beta.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-2-beta.md',
-            contentSha256: 'sha-beta',
-            sizeBytes: 20
-        });
-        const otherWorkspace = ctx.store.upsertAsset({
-            assetId: 'asset-doc-3',
-            workspaceId: 'workspace-2',
-            kind: 'document',
-            originalFilename: 'gamma.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-2/assets/documents/asset-doc-3-gamma.md',
-            contentSha256: 'sha-gamma',
-            sizeBytes: 30
-        });
-        expect(first.referenceNumber).toBe(1);
-        expect(second.referenceNumber).toBe(2);
-        expect(otherWorkspace.referenceNumber).toBe(1);
-    });
-    it('assigns sequential image reference numbers per workspace independently from documents', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        const firstImage = ctx.store.upsertAsset({
-            assetId: 'asset-image-1',
-            workspaceId: 'workspace-1',
-            kind: 'image',
-            originalFilename: 'alpha.png',
-            mimeType: 'image/png',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/images/asset-image-1-alpha.png',
-            contentSha256: 'sha-image-alpha',
-            sizeBytes: 10
-        });
-        const document = ctx.store.upsertAsset({
-            assetId: 'asset-doc-1',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'alpha.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-1-alpha.md',
-            contentSha256: 'sha-doc-alpha',
-            sizeBytes: 20
-        });
-        const secondImage = ctx.store.upsertAsset({
-            assetId: 'asset-image-2',
-            workspaceId: 'workspace-1',
-            kind: 'image',
-            originalFilename: 'beta.png',
-            mimeType: 'image/png',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/images/asset-image-2-beta.png',
-            contentSha256: 'sha-image-beta',
-            sizeBytes: 30
-        });
-        expect(firstImage.referenceNumber).toBe(1);
-        expect(document.referenceNumber).toBe(1);
-        expect(secondImage.referenceNumber).toBe(2);
-    });
-    it('preserves an existing readable asset reference number during normal upserts', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        const created = ctx.store.upsertAsset({
-            assetId: 'asset-doc-stable-1',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'alpha.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-stable-1-alpha.md',
-            contentSha256: 'sha-alpha',
-            sizeBytes: 10,
-            referenceNumber: 5
-        });
-        const updated = ctx.store.upsertAsset({
-            assetId: 'asset-doc-stable-1',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'alpha.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/asset-doc-stable-1-alpha.md',
-            contentSha256: 'sha-alpha-2',
-            sizeBytes: 12,
-            referenceNumber: 11
-        });
-        expect(created.referenceNumber).toBe(5);
-        expect(updated.referenceNumber).toBe(5);
-    });
-    it('allows readable asset reference reassignment only when explicitly requested', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        ctx.store.upsertAsset({
-            assetId: 'asset-image-stable-1',
-            workspaceId: 'workspace-1',
-            kind: 'image',
-            originalFilename: 'alpha.png',
-            mimeType: 'image/png',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/images/asset-image-stable-1-alpha.png',
-            contentSha256: 'sha-image-alpha',
-            sizeBytes: 10,
-            referenceNumber: 3
-        });
-        const repaired = ctx.store.upsertAsset({
-            assetId: 'asset-image-stable-1',
-            workspaceId: 'workspace-1',
-            kind: 'image',
-            originalFilename: 'alpha.png',
-            mimeType: 'image/png',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/images/asset-image-stable-1-alpha.png',
-            contentSha256: 'sha-image-beta',
-            sizeBytes: 10,
-            referenceNumber: 7,
-            allowReferenceNumberReassignment: true
-        });
-        expect(repaired.referenceNumber).toBe(7);
-    });
-    it('skips stale sequence values when allocating readable asset references', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        ctx.store.upsertAsset({
-            assetId: 'asset-doc-existing',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'existing.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/existing.md',
-            contentSha256: 'sha-existing',
-            sizeBytes: 10,
-            referenceNumber: 1
-        });
-        ctx.db.prepare(`
-            INSERT INTO workspace_document_reference_sequences (tenant_id, workspace_id, next_reference_number)
-            VALUES ('default', 'workspace-1', 0)
-            ON CONFLICT (tenant_id, workspace_id) DO UPDATE SET next_reference_number = 0
-        `).run();
-        const created = ctx.store.upsertAsset({
-            assetId: 'asset-doc-new',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'new.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/new.md',
-            contentSha256: 'sha-new',
-            sizeBytes: 10
-        });
-        expect(created.referenceNumber).toBe(2);
-    });
-    it('retries with the next available readable reference when the database raises a reference collision', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        ctx.store.upsertAsset({
-            assetId: 'asset-doc-existing',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'existing.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/existing.md',
-            contentSha256: 'sha-existing',
-            sizeBytes: 10,
-            referenceNumber: 7
-        });
-        const originalPrepare = ctx.db.prepare.bind(ctx.db);
-        let forcedCollision = false;
-        vi.spyOn(ctx.db, 'prepare').mockImplementation((sql) => {
-            const statement = originalPrepare(sql);
-            if (!sql.includes('INSERT INTO workspace_assets')) {
-                return statement;
-            }
-            return {
-                ...statement,
-                run: (...args) => {
-                    const referenceNumberArg = args[12];
-                    if (!forcedCollision && referenceNumberArg === 8) {
-                        forcedCollision = true;
-                        throw new Error('UNIQUE constraint failed: workspace_assets.tenant_id, workspace_assets.workspace_id, workspace_assets.kind, workspace_assets.reference_number');
-                    }
-                    return statement.run(...args);
-                }
-            };
-        });
-        const created = ctx.store.upsertAsset({
-            assetId: 'asset-doc-new',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'new.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/new.md',
-            contentSha256: 'sha-new',
-            sizeBytes: 10,
-            referenceNumber: 8
-        });
-        expect(created.referenceNumber).toBe(8 + 1);
-    });
-    it('migrates old cross-kind asset reference indexes before backfilling image references', () => {
-        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'taskforce-workspace-assets-migrate-'));
-        const dbPath = path.join(root, 'taskforce.db');
-        const db = createDatabaseAdapter({ sqliteDbPath: dbPath });
-        cleanups.push(() => {
-            db.close();
-            fs.rmSync(root, { recursive: true, force: true });
-        });
-        ensureTaskAssetsSchema(db);
-        ensureWorkspaceAssetsSchema(db);
-        db.exec(`ALTER TABLE workspace_assets ADD COLUMN reference_number INTEGER`);
-        db.exec(`
-            CREATE TABLE workspace_document_reference_sequences (
-                tenant_id TEXT NOT NULL DEFAULT 'default',
-                workspace_id TEXT NOT NULL DEFAULT 'default',
-                next_reference_number INTEGER NOT NULL DEFAULT 0,
-                PRIMARY KEY (tenant_id, workspace_id)
-            );
-            CREATE UNIQUE INDEX idx_workspace_assets_workspace_reference
-            ON workspace_assets(tenant_id, workspace_id, reference_number);
-        `);
-        const insertAsset = 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,
-                version,
-                is_latest,
-                scan_status,
-                scan_engine,
-                scan_details,
-                created_by_user_id,
-                created_at,
-                updated_at,
-                deleted_at,
-                purge_after,
-                reference_number
-            ) VALUES (?, 'default', 'workspace-1', ?, NULL, ?, ?, 'local', ?, ?, ?, NULL, 1, 1, 'clean', NULL, NULL, NULL, ?, ?, NULL, NULL, ?)
-        `);
-        insertAsset.run('asset-doc-1', 'document', 'doc-1.md', 'text/markdown', 'workspaces/workspace-1/assets/documents/asset-doc-1-doc-1.md', 'sha-doc-1', 10, '2026-03-25T12:00:00.000Z', '2026-03-25T12:00:00.000Z', 1);
-        insertAsset.run('asset-doc-2', 'document', 'doc-2.md', 'text/markdown', 'workspaces/workspace-1/assets/documents/asset-doc-2-doc-2.md', 'sha-doc-2', 20, '2026-03-25T12:01:00.000Z', '2026-03-25T12:01:00.000Z', 2);
-        insertAsset.run('asset-image-1', 'image', 'image-1.png', 'image/png', 'workspaces/workspace-1/assets/images/asset-image-1-image-1.png', 'sha-image-1', 30, '2026-03-25T12:02:00.000Z', '2026-03-25T12:02:00.000Z', null);
-        insertAsset.run('asset-image-2', 'image', 'image-2.png', 'image/png', 'workspaces/workspace-1/assets/images/asset-image-2-image-2.png', 'sha-image-2', 40, '2026-03-25T12:03:00.000Z', '2026-03-25T12:03:00.000Z', null);
-        expect(() => ensureDocumentReferenceSchema(db)).not.toThrow();
-        const migrated = db.prepare(`
-            SELECT kind, reference_number
-            FROM workspace_assets
-            WHERE tenant_id = 'default' AND workspace_id = 'workspace-1'
-            ORDER BY kind ASC, asset_id ASC
-        `).all();
-        expect(migrated).toEqual([
-            { kind: 'document', reference_number: 1 },
-            { kind: 'document', reference_number: 2 },
-            { kind: 'image', reference_number: 1 },
-            { kind: 'image', reference_number: 2 }
-        ]);
-    });
-    it('lists workspace assets and excludes deleted rows by default', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        ctx.store.upsertAsset({
-            assetId: 'asset-a',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'a.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/asset-a-a.md',
-            contentSha256: 'sha-a',
-            sizeBytes: 10
-        });
-        ctx.store.upsertAsset({
-            assetId: 'asset-b',
-            workspaceId: 'workspace-1',
-            kind: 'image',
-            originalFilename: 'b.png',
-            mimeType: 'image/png',
-            storageProvider: 'r2',
-            storageKey: 'workspaces/workspace-1/assets/images/asset-b-b.png',
-            contentSha256: 'sha-b',
-            sizeBytes: 20
-        });
-        ctx.store.markDeleted('asset-b', 'workspace-1', '2026-03-17T00:00:00.000Z', '2026-03-24T00:00:00.000Z');
-        const active = ctx.store.listByWorkspace('workspace-1');
-        expect(active.map((entry) => entry.assetId)).toEqual(['asset-a']);
-        const all = ctx.store.listByWorkspace('workspace-1', { includeDeleted: true });
-        expect(all.map((entry) => entry.assetId).sort()).toEqual(['asset-a', 'asset-b']);
-    });
-    it('creates, lists, and soft-deletes generic target links while preserving task compatibility helpers', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        ctx.store.upsertAsset({
-            assetId: 'asset-link-1',
-            workspaceId: 'workspace-1',
-            kind: 'file',
-            originalFilename: 'brief.pdf',
-            mimeType: 'application/pdf',
-            storageProvider: 'r2',
-            storageKey: 'workspaces/workspace-1/assets/files/asset-link-1-brief.pdf',
-            contentSha256: 'sha-link',
-            sizeBytes: 55
-        });
-        ctx.store.upsertLink({
-            workspaceId: 'workspace-1',
-            assetId: 'asset-link-1',
-            targetType: 'task',
-            targetId: 'task-1',
-            role: 'attachment',
-            sortOrder: 2
-        });
-        ctx.store.upsertLink({
-            workspaceId: 'workspace-1',
-            assetId: 'asset-link-1',
-            targetType: 'initiative',
-            targetId: 'initiative-2',
-            role: 'reference',
-            sortOrder: 1
-        });
-        const taskLinks = ctx.store.listLinksForTask('task-1', 'workspace-1');
-        expect(taskLinks).toHaveLength(1);
-        expect(taskLinks[0]).toMatchObject({ assetId: 'asset-link-1', role: 'attachment', targetType: 'task', targetId: 'task-1', taskId: 'task-1' });
-        const initiativeLinks = ctx.store.listLinksForTarget('initiative', 'initiative-2', 'workspace-1');
-        expect(initiativeLinks).toHaveLength(1);
-        expect(initiativeLinks[0]).toMatchObject({ assetId: 'asset-link-1', role: 'reference', targetType: 'initiative', targetId: 'initiative-2', taskId: null });
-        const assetLinks = ctx.store.listLinksForAsset('asset-link-1', 'workspace-1');
-        expect(assetLinks).toHaveLength(2);
-        expect(assetLinks.map((entry) => [entry.targetType, entry.targetId])).toEqual([
-            ['initiative', 'initiative-2'],
-            ['task', 'task-1'],
-        ]);
-        expect(ctx.store.deleteLink({
-            workspaceId: 'workspace-1',
-            assetId: 'asset-link-1',
-            targetType: 'task',
-            targetId: 'task-1',
-            role: 'attachment'
-        })).toBe(true);
-        expect(ctx.store.listLinksForTask('task-1', 'workspace-1')).toHaveLength(0);
-        expect(ctx.store.listLinksForTask('task-1', 'workspace-1', { includeDeleted: true })).toHaveLength(1);
-    });
-    it('resolves legacy path-keyed writes through a stable canonical asset id', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        const created = ctx.store.upsertAsset({
-            assetId: 'asset-legacy-1',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'notes.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'task-data/task-1/attachments/notes.md',
-            contentSha256: 'sha-v1',
-            sizeBytes: 12,
-            documentId: 'doc-legacy-1',
-            version: 1
-        });
-        const samePath = ctx.store.getByStorageKey('task-data/task-1/attachments/notes.md', 'workspace-1');
-        expect(samePath).toMatchObject({
-            assetId: created.assetId,
-            documentId: 'doc-legacy-1',
-            version: 1
-        });
-        ctx.store.upsertAsset({
-            assetId: created.assetId,
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            originalFilename: 'notes.md',
-            mimeType: 'text/markdown',
-            storageProvider: 'local',
-            storageKey: 'task-data/task-1/attachments/notes.md',
-            contentSha256: 'sha-v2',
-            sizeBytes: 24,
-            documentId: 'doc-legacy-1',
-            version: 2
-        });
-        const updated = ctx.store.getByStorageKey('task-data/task-1/attachments/notes.md', 'workspace-1');
-        expect(updated).toMatchObject({
-            assetId: created.assetId,
-            documentId: 'doc-legacy-1',
-            version: 2,
-            contentSha256: 'sha-v2',
-            sizeBytes: 24
-        });
-    });
-    it('normalizes invalid document metadata for txt files into plain files', () => {
-        const ctx = makeStore();
-        cleanups.push(() => ctx.cleanup());
-        const created = ctx.store.upsertAsset({
-            assetId: 'asset-invalid-doc-1',
-            workspaceId: 'workspace-1',
-            kind: 'document',
-            logicalName: 'diagnostic.txt',
-            originalFilename: 'diagnostic.txt',
-            mimeType: 'text/plain',
-            storageProvider: 'local',
-            storageKey: 'workspaces/workspace-1/assets/documents/asset-invalid-doc-1-diagnostic.txt',
-            contentSha256: 'sha-invalid-doc-1',
-            sizeBytes: 42,
-            documentId: 'doc-invalid',
-            version: 1
-        });
-        expect(created.kind).toBe('file');
-        expect(created.referenceNumber).toBeNull();
-        expect(created.documentId).toBeNull();
-        expect(created.version).toBeNull();
-        const fetched = ctx.store.get('asset-invalid-doc-1', 'workspace-1');
-        expect(fetched).toMatchObject({
-            kind: 'file',
-            referenceNumber: null,
-            documentId: null,
-            version: null
-        });
-    });
-});

package/dist/sync/cloudSyncApi.test.d.ts

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