@nest-yalc-2/omnikernel-module 2.2.1 → 2.2.4

package/src/__tests__/omnikernel.diagnostics.spec.ts

@@ -1,94 +1,94 @@
-import { describe, expect, it, jest } from "@jest/globals";
-
-import { collectOmniKernelQueryPlanEvidence } from '../omnikernel.diagnostics.js';
-
-const sample = {
-  scopeId: "scope-alpha",
-  recordKind: "generic",
-  recordStatus: "active",
-  sourceRecordId: "record-1",
-  relationKind: "references",
-  relationStatus: "active",
-};
-
-describe("OmniKernel query-plan diagnostics", () => {
-  it("records sqlite index evidence for the bounded generated read shapes", async () => {
-    const query = jest
-      .fn()
-      .mockResolvedValueOnce([
-        {
-          detail:
-            "SEARCH omni-record USING INDEX omni_record_scope_kind_status_guid_idx",
-        },
-      ])
-      .mockResolvedValueOnce([
-        {
-          detail:
-            "SEARCH omni-relation USING INDEX omni_relation_scope_source_kind_status_created_guid_idx",
-        },
-      ]);
-
-    const evidence = await collectOmniKernelQueryPlanEvidence(
-      { options: { type: "sqlite" }, query } as never,
-      sample,
-    );
-
-    expect(evidence).toMatchObject({
-      dialect: "sqlite",
-      usesRecordGridIndex: true,
-      usesRelationSourceIndex: true,
-    });
-    expect(query.mock.calls[0][0]).toContain("EXPLAIN QUERY PLAN");
-    expect(query.mock.calls[1][1]).toEqual([
-      sample.scopeId,
-      sample.sourceRecordId,
-      sample.relationKind,
-      sample.relationStatus,
-    ]);
-  });
-
-  it("records PostgreSQL JSON-plan index evidence", async () => {
-    const query = jest
-      .fn()
-      .mockResolvedValueOnce([
-        {
-          "QUERY PLAN": [
-            {
-              Plan: { "Index Name": "omni_record_scope_kind_status_guid_idx" },
-            },
-          ],
-        },
-      ])
-      .mockResolvedValueOnce([
-        {
-          "QUERY PLAN": [
-            {
-              Plan: {
-                "Index Name":
-                  "omni_relation_scope_source_kind_status_created_guid_idx",
-              },
-            },
-          ],
-        },
-      ]);
-
-    const evidence = await collectOmniKernelQueryPlanEvidence(
-      { options: { type: "postgres" }, query } as never,
-      sample,
-    );
-
-    expect(evidence.dialect).toBe("postgres");
-    expect(evidence.usesRecordGridIndex).toBe(true);
-    expect(evidence.usesRelationSourceIndex).toBe(true);
-    expect(query.mock.calls[0][0]).toContain("EXPLAIN (FORMAT JSON)");
-  });
-
-  it("rejects unsupported drivers instead of guessing their query-plan syntax", async () => {
-    await expect(
-      collectOmniKernelQueryPlanEvidence(
-        { options: { type: "mysql" }, query: jest.fn() } as never,
-        sample,
-      ),
-    ).rejects.toThrow("sqlite and postgres only");
-  });
-});
+import { describe, expect, it, jest } from "@jest/globals";
+
+import { collectOmniKernelQueryPlanEvidence } from '../omnikernel.diagnostics.js';
+
+const sample = {
+  scopeId: "scope-alpha",
+  recordKind: "generic",
+  recordStatus: "active",
+  sourceRecordId: "record-1",
+  relationKind: "references",
+  relationStatus: "active",
+};
+
+describe("OmniKernel query-plan diagnostics", () => {
+  it("records sqlite index evidence for the bounded generated read shapes", async () => {
+    const query = jest
+      .fn()
+      .mockResolvedValueOnce([
+        {
+          detail:
+            "SEARCH omni-record USING INDEX omni_record_scope_kind_status_guid_idx",
+        },
+      ])
+      .mockResolvedValueOnce([
+        {
+          detail:
+            "SEARCH omni-relation USING INDEX omni_relation_scope_source_kind_status_created_guid_idx",
+        },
+      ]);
+
+    const evidence = await collectOmniKernelQueryPlanEvidence(
+      { options: { type: "sqlite" }, query } as never,
+      sample,
+    );
+
+    expect(evidence).toMatchObject({
+      dialect: "sqlite",
+      usesRecordGridIndex: true,
+      usesRelationSourceIndex: true,
+    });
+    expect(query.mock.calls[0][0]).toContain("EXPLAIN QUERY PLAN");
+    expect(query.mock.calls[1][1]).toEqual([
+      sample.scopeId,
+      sample.sourceRecordId,
+      sample.relationKind,
+      sample.relationStatus,
+    ]);
+  });
+
+  it("records PostgreSQL JSON-plan index evidence", async () => {
+    const query = jest
+      .fn()
+      .mockResolvedValueOnce([
+        {
+          "QUERY PLAN": [
+            {
+              Plan: { "Index Name": "omni_record_scope_kind_status_guid_idx" },
+            },
+          ],
+        },
+      ])
+      .mockResolvedValueOnce([
+        {
+          "QUERY PLAN": [
+            {
+              Plan: {
+                "Index Name":
+                  "omni_relation_scope_source_kind_status_created_guid_idx",
+              },
+            },
+          ],
+        },
+      ]);
+
+    const evidence = await collectOmniKernelQueryPlanEvidence(
+      { options: { type: "postgres" }, query } as never,
+      sample,
+    );
+
+    expect(evidence.dialect).toBe("postgres");
+    expect(evidence.usesRecordGridIndex).toBe(true);
+    expect(evidence.usesRelationSourceIndex).toBe(true);
+    expect(query.mock.calls[0][0]).toContain("EXPLAIN (FORMAT JSON)");
+  });
+
+  it("rejects unsupported drivers instead of guessing their query-plan syntax", async () => {
+    await expect(
+      collectOmniKernelQueryPlanEvidence(
+        { options: { type: "mysql" }, query: jest.fn() } as never,
+        sample,
+      ),
+    ).rejects.toThrow("sqlite and postgres only");
+  });
+});

package/src/__tests__/omnikernel.module.spec.ts

@@ -1,40 +1,38 @@
-import { describe, expect, it, jest } from '@jest/globals';
-import 'reflect-metadata';
-import { OmniKernelQueryService } from '../omnikernel.query.service.js';
-
-import * as OmniNamedBackend from '../omni-named.backend.js';
-import * as OmniRecordBackend from '../omni-record.backend.js';
-import * as OmniRelationBackend from '../omni-relation.backend.js';
-import * as OmniCollectionBackend from '../omni-collection.backend.js';
-import * as OmniDocumentBackend from '../omni-document.backend.js';
-import * as OmniExternalRefBackend from '../omni-external-ref.backend.js';
-
-const omniNamedBackendProvidersFactory = jest.spyOn(OmniNamedBackend as any, 'omniNamedBackendProvidersFactory').mockReturnValue({ providers: ['named-backend'] });
-const omniRecordBackendProvidersFactory = jest.spyOn(OmniRecordBackend as any, 'omniRecordBackendProvidersFactory').mockReturnValue({ providers: ['record-backend'] });
-const omniRelationBackendProvidersFactory = jest.spyOn(OmniRelationBackend as any, 'omniRelationBackendProvidersFactory').mockReturnValue({ providers: ['relation-backend'] });
-const omniCollectionBackendProvidersFactory = jest.spyOn(OmniCollectionBackend as any, 'omniCollectionBackendProvidersFactory').mockReturnValue({ providers: ['collection-backend'] });
-const omniDocumentBackendProvidersFactory = jest.spyOn(OmniDocumentBackend as any, 'omniDocumentBackendProvidersFactory').mockReturnValue({ providers: ['document-backend'] });
-const omniExternalRefBackendProvidersFactory = jest.spyOn(OmniExternalRefBackend as any, 'omniExternalRefBackendProvidersFactory').mockReturnValue({ providers: ['external-ref-backend'] });
-
-import { OmniKernelModule } from '../omnikernel.module.js';
-
-describe('OmniKernelModule', () => {
-  it('registers only backend substrate providers', () => {
-    const module = OmniKernelModule.register('test');
-
-    expect(module).toBeDefined();
-    expect(omniNamedBackendProvidersFactory).toHaveBeenCalledWith('test');
-    expect(module.providers).toEqual(
-      expect.arrayContaining([
-        'named-backend',
-        'record-backend',
-        'relation-backend',
-        'collection-backend',
-        'document-backend',
-        'external-ref-backend',
-        expect.objectContaining({ provide: OmniKernelQueryService }),
-      ]),
-    );
-    expect(module.controllers).toBeUndefined();
-  });
-});
+import { describe, expect, it, jest } from '@jest/globals';
+import 'reflect-metadata';
+import { OmniKernelQueryService } from '../omnikernel.query.service.js';
+
+
+import * as OmniNamedBackend from '../omni-named.backend.js';
+import * as OmniRecordBackend from '../omni-record.backend.js';
+import * as OmniRelationBackend from '../omni-relation.backend.js';
+import * as OmniCollectionBackend from '../omni-collection.backend.js';
+import * as OmniDocumentBackend from '../omni-document.backend.js';
+import * as OmniExternalRefBackend from '../omni-external-ref.backend.js';
+
+const omniNamedBackendProvidersFactory = OmniNamedBackend.omniNamedBackendProvidersFactory as jest.Mock;
+const omniRecordBackendProvidersFactory = OmniRecordBackend.omniRecordBackendProvidersFactory as jest.Mock;
+const omniRelationBackendProvidersFactory = OmniRelationBackend.omniRelationBackendProvidersFactory as jest.Mock;
+const omniCollectionBackendProvidersFactory = OmniCollectionBackend.omniCollectionBackendProvidersFactory as jest.Mock;
+const omniDocumentBackendProvidersFactory = OmniDocumentBackend.omniDocumentBackendProvidersFactory as jest.Mock;
+const omniExternalRefBackendProvidersFactory = OmniExternalRefBackend.omniExternalRefBackendProvidersFactory as jest.Mock;
+
+import { OmniKernelModule } from '../omnikernel.module.js';
+
+describe('OmniKernelModule', () => {
+  it('registers only backend substrate providers', () => {
+    const module = OmniKernelModule.register('test');
+
+    expect(module).toBeDefined();
+    
+    expect(module.providers).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ provide: 'OmniNamedEntityGenericService' }),
+        expect.objectContaining({ provide: 'OmniRecordEntityGenericService' }),
+        expect.objectContaining({ provide: 'OmniRelationEntityGenericService' }),
+        expect.objectContaining({ provide: OmniKernelQueryService }),
+      ]),
+    );
+    expect(module.controllers).toBeUndefined();
+  });
+});

package/src/__tests__/omnikernel.persistence.spec.ts

@@ -1,154 +1,154 @@
-import { afterEach, beforeEach, describe, expect, it } from '@jest/globals';
-import { DataSource } from 'typeorm';
-
-import { OmniNamedEntity } from '../base/omni-named.entity.js';
-import { OmniRecordEntity } from '../base/omni-record.entity.js';
-import { OmniRelationEntity } from '../base/omni-relation.entity.js';
-import { OmniCollectionEntity } from '../omni-collection.entity.js';
-import { OmniCollectionKind } from '../omni-collection-kind.enum.js';
-import { OmniDocumentEntity } from '../omni-document.entity.js';
-import { OmniDocumentKind } from '../omni-document-kind.enum.js';
-import { OmniRecordStatus } from '../omni-record-status.enum.js';
-import { OmniRelationKind } from '../omni-relation-kind.enum.js';
-import { OmniRelationStatus } from '../omni-relation-status.enum.js';
-
-describe('OmniKernel persistence', () => {
-  let dataSource: DataSource;
-
-  beforeEach(async () => {
-    dataSource = new DataSource({
-      type: 'sqlite',
-      database: ':memory:',
-      dropSchema: true,
-      synchronize: true,
-      entities: [
-        OmniNamedEntity,
-        OmniRecordEntity,
-        OmniCollectionEntity,
-        OmniDocumentEntity,
-        OmniRelationEntity,
-      ],
-    });
-
-    await dataSource.initialize();
-  });
-
-  afterEach(async () => {
-    if (dataSource.isInitialized) {
-      await dataSource.destroy();
-    }
-  });
-
-  it('stores collections and documents in omni-record and resolves graph links back through the shared record hierarchy', async () => {
-    const recordRepo = dataSource.getRepository(OmniRecordEntity);
-    const collectionRepo = dataSource.getRepository(OmniCollectionEntity);
-    const documentRepo = dataSource.getRepository(OmniDocumentEntity);
-    const relationRepo = dataSource.getRepository(OmniRelationEntity);
-
-    await recordRepo.insert(
-      recordRepo.create({
-        guid: '11111111-1111-1111-1111-111111111111',
-        title: 'Task record',
-        kind: 'task',
-        status: OmniRecordStatus.Draft,
-      }),
-    );
-    await documentRepo.insert(
-      documentRepo.create({
-        guid: '22222222-2222-2222-2222-222222222222',
-        title: 'Document record',
-        status: OmniRecordStatus.Draft,
-        documentKind: OmniDocumentKind.Note,
-      }),
-    );
-    await collectionRepo.insert(
-      collectionRepo.create({
-        guid: '44444444-4444-4444-4444-444444444444',
-        title: 'Knowledge base',
-        status: OmniRecordStatus.Active,
-        collectionKind: OmniCollectionKind.Folder,
-        summary: 'Primary document container',
-      }),
-    );
-    await relationRepo.insert(
-      relationRepo.create({
-        guid: '33333333-3333-3333-3333-333333333333',
-        sourceRecordId: '11111111-1111-1111-1111-111111111111',
-        targetRecordId: '22222222-2222-2222-2222-222222222222',
-        kind: OmniRelationKind.References,
-        status: OmniRelationStatus.Active,
-      }),
-    );
-    await relationRepo.insert(
-      relationRepo.create({
-        guid: '55555555-5555-5555-5555-555555555555',
-        sourceRecordId: '44444444-4444-4444-4444-444444444444',
-        targetRecordId: '22222222-2222-2222-2222-222222222222',
-        kind: OmniRelationKind.Contains,
-        status: OmniRelationStatus.Active,
-      }),
-    );
-
-    const rows = await dataSource.query(
-      'select guid, kind, recordType, collectionKind, documentKind from "omni-record" order by guid',
-    );
-
-    expect(rows).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          guid: '11111111-1111-1111-1111-111111111111',
-          kind: 'task',
-        }),
-        expect.objectContaining({
-          guid: '22222222-2222-2222-2222-222222222222',
-          kind: OmniDocumentKind.Document,
-          recordType: OmniDocumentKind.Document,
-          documentKind: OmniDocumentKind.Note,
-        }),
-        expect.objectContaining({
-          guid: '44444444-4444-4444-4444-444444444444',
-          kind: OmniCollectionKind.Collection,
-          recordType: OmniCollectionKind.Collection,
-          collectionKind: OmniCollectionKind.Folder,
-        }),
-      ]),
-    );
-
-    const relation = await relationRepo.findOneOrFail({
-      where: { guid: '33333333-3333-3333-3333-333333333333' },
-      relations: {
-        sourceRecord: true,
-        targetRecord: true,
-      },
-    });
-
-    expect(relation.sourceRecord.guid).toBe(
-      '11111111-1111-1111-1111-111111111111',
-    );
-    expect(relation.targetRecord).toBeInstanceOf(OmniDocumentEntity);
-    expect(relation.targetRecord.guid).toBe(
-      '22222222-2222-2222-2222-222222222222',
-    );
-    expect((relation.targetRecord as OmniDocumentEntity).kind).toBe(
-      OmniDocumentKind.Document,
-    );
-
-    const membershipRelation = await relationRepo.findOneOrFail({
-      where: { guid: '55555555-5555-5555-5555-555555555555' },
-      relations: {
-        sourceRecord: true,
-        targetRecord: true,
-      },
-    });
-
-    expect(membershipRelation.sourceRecord).toBeInstanceOf(OmniCollectionEntity);
-    expect(membershipRelation.sourceRecord.guid).toBe(
-      '44444444-4444-4444-4444-444444444444',
-    );
-    expect((membershipRelation.sourceRecord as OmniCollectionEntity).kind).toBe(
-      OmniCollectionKind.Collection,
-    );
-    expect(membershipRelation.targetRecord).toBeInstanceOf(OmniDocumentEntity);
-    expect(membershipRelation.kind).toBe(OmniRelationKind.Contains);
-  });
-});
+import { afterEach, beforeEach, describe, expect, it } from '@jest/globals';
+import { DataSource } from 'typeorm';
+
+import { OmniNamedEntity } from '../base/omni-named.entity.js';
+import { OmniRecordEntity } from '../base/omni-record.entity.js';
+import { OmniRelationEntity } from '../base/omni-relation.entity.js';
+import { OmniCollectionEntity } from '../omni-collection.entity.js';
+import { OmniCollectionKind } from '../omni-collection-kind.enum.js';
+import { OmniDocumentEntity } from '../omni-document.entity.js';
+import { OmniDocumentKind } from '../omni-document-kind.enum.js';
+import { OmniRecordStatus } from '../omni-record-status.enum.js';
+import { OmniRelationKind } from '../omni-relation-kind.enum.js';
+import { OmniRelationStatus } from '../omni-relation-status.enum.js';
+
+describe('OmniKernel persistence', () => {
+  let dataSource: DataSource;
+
+  beforeEach(async () => {
+    dataSource = new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      dropSchema: true,
+      synchronize: true,
+      entities: [
+        OmniNamedEntity,
+        OmniRecordEntity,
+        OmniCollectionEntity,
+        OmniDocumentEntity,
+        OmniRelationEntity,
+      ],
+    });
+
+    await dataSource.initialize();
+  });
+
+  afterEach(async () => {
+    if (dataSource.isInitialized) {
+      await dataSource.destroy();
+    }
+  });
+
+  it('stores collections and documents in omni-record and resolves graph links back through the shared record hierarchy', async () => {
+    const recordRepo = dataSource.getRepository(OmniRecordEntity);
+    const collectionRepo = dataSource.getRepository(OmniCollectionEntity);
+    const documentRepo = dataSource.getRepository(OmniDocumentEntity);
+    const relationRepo = dataSource.getRepository(OmniRelationEntity);
+
+    await recordRepo.insert(
+      recordRepo.create({
+        guid: '11111111-1111-1111-1111-111111111111',
+        title: 'Task record',
+        kind: 'task',
+        status: OmniRecordStatus.Draft,
+      }),
+    );
+    await documentRepo.insert(
+      documentRepo.create({
+        guid: '22222222-2222-2222-2222-222222222222',
+        title: 'Document record',
+        status: OmniRecordStatus.Draft,
+        documentKind: OmniDocumentKind.Note,
+      }),
+    );
+    await collectionRepo.insert(
+      collectionRepo.create({
+        guid: '44444444-4444-4444-4444-444444444444',
+        title: 'Knowledge base',
+        status: OmniRecordStatus.Active,
+        collectionKind: OmniCollectionKind.Folder,
+        summary: 'Primary document container',
+      }),
+    );
+    await relationRepo.insert(
+      relationRepo.create({
+        guid: '33333333-3333-3333-3333-333333333333',
+        sourceRecordId: '11111111-1111-1111-1111-111111111111',
+        targetRecordId: '22222222-2222-2222-2222-222222222222',
+        kind: OmniRelationKind.References,
+        status: OmniRelationStatus.Active,
+      }),
+    );
+    await relationRepo.insert(
+      relationRepo.create({
+        guid: '55555555-5555-5555-5555-555555555555',
+        sourceRecordId: '44444444-4444-4444-4444-444444444444',
+        targetRecordId: '22222222-2222-2222-2222-222222222222',
+        kind: OmniRelationKind.Contains,
+        status: OmniRelationStatus.Active,
+      }),
+    );
+
+    const rows = await dataSource.query(
+      'select guid, kind, recordType, collectionKind, documentKind from "omni-record" order by guid',
+    );
+
+    expect(rows).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          guid: '11111111-1111-1111-1111-111111111111',
+          kind: 'task',
+        }),
+        expect.objectContaining({
+          guid: '22222222-2222-2222-2222-222222222222',
+          kind: OmniDocumentKind.Document,
+          recordType: OmniDocumentKind.Document,
+          documentKind: OmniDocumentKind.Note,
+        }),
+        expect.objectContaining({
+          guid: '44444444-4444-4444-4444-444444444444',
+          kind: OmniCollectionKind.Collection,
+          recordType: OmniCollectionKind.Collection,
+          collectionKind: OmniCollectionKind.Folder,
+        }),
+      ]),
+    );
+
+    const relation = await relationRepo.findOneOrFail({
+      where: { guid: '33333333-3333-3333-3333-333333333333' },
+      relations: {
+        sourceRecord: true,
+        targetRecord: true,
+      },
+    });
+
+    expect(relation.sourceRecord.guid).toBe(
+      '11111111-1111-1111-1111-111111111111',
+    );
+    expect(relation.targetRecord).toBeInstanceOf(OmniDocumentEntity);
+    expect(relation.targetRecord.guid).toBe(
+      '22222222-2222-2222-2222-222222222222',
+    );
+    expect((relation.targetRecord as OmniDocumentEntity).kind).toBe(
+      OmniDocumentKind.Document,
+    );
+
+    const membershipRelation = await relationRepo.findOneOrFail({
+      where: { guid: '55555555-5555-5555-5555-555555555555' },
+      relations: {
+        sourceRecord: true,
+        targetRecord: true,
+      },
+    });
+
+    expect(membershipRelation.sourceRecord).toBeInstanceOf(OmniCollectionEntity);
+    expect(membershipRelation.sourceRecord.guid).toBe(
+      '44444444-4444-4444-4444-444444444444',
+    );
+    expect((membershipRelation.sourceRecord as OmniCollectionEntity).kind).toBe(
+      OmniCollectionKind.Collection,
+    );
+    expect(membershipRelation.targetRecord).toBeInstanceOf(OmniDocumentEntity);
+    expect(membershipRelation.kind).toBe(OmniRelationKind.Contains);
+  });
+});