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

package/src/__tests__/omni-record.entity.spec.ts

@@ -1,32 +1,32 @@
-import { describe, expect, it } from '@jest/globals';
-import { getMetadataArgsStorage } from 'typeorm';
-
-import { OmniNamedEntity } from '../base/omni-named.entity.js';
-import { OmniRecordEntity } from '../base/omni-record.entity.js';
-
-describe('OmniRecordEntity', () => {
-  it('extends OmniNamedEntity', () => {
-    expect(new OmniRecordEntity()).toBeInstanceOf(OmniNamedEntity);
-  });
-
-  it('registers core columns and directional relations', () => {
-    const metadata = getMetadataArgsStorage();
-    const table = metadata.tables.find(
-      (item) => item.target === OmniRecordEntity,
-    );
-    const entityColumns = metadata.columns
-      .filter((item) => item.target === OmniRecordEntity)
-      .map((item) => item.propertyName);
-    const relations = metadata.relations
-      .filter((item) => item.target === OmniRecordEntity)
-      .map((item) => item.propertyName);
-
-    expect(table?.name).toBe('omni-record');
-    expect(entityColumns).toEqual(
-      expect.arrayContaining(['kind', 'status', 'payload']),
-    );
-    expect(relations).toEqual(
-      expect.arrayContaining(['outgoingRelations', 'incomingRelations']),
-    );
-  });
-});
+import { describe, expect, it } from '@jest/globals';
+import { getMetadataArgsStorage } from 'typeorm';
+
+import { OmniNamedEntity } from '../base/omni-named.entity.js';
+import { OmniRecordEntity } from '../base/omni-record.entity.js';
+
+describe('OmniRecordEntity', () => {
+  it('extends OmniNamedEntity', () => {
+    expect(new OmniRecordEntity()).toBeInstanceOf(OmniNamedEntity);
+  });
+
+  it('registers core columns and directional relations', () => {
+    const metadata = getMetadataArgsStorage();
+    const table = metadata.tables.find(
+      (item) => item.target === OmniRecordEntity,
+    );
+    const entityColumns = metadata.columns
+      .filter((item) => item.target === OmniRecordEntity)
+      .map((item) => item.propertyName);
+    const relations = metadata.relations
+      .filter((item) => item.target === OmniRecordEntity)
+      .map((item) => item.propertyName);
+
+    expect(table?.name).toBe('omni-record');
+    expect(entityColumns).toEqual(
+      expect.arrayContaining(['kind', 'status', 'payload']),
+    );
+    expect(relations).toEqual(
+      expect.arrayContaining(['outgoingRelations', 'incomingRelations']),
+    );
+  });
+});

package/src/__tests__/omni-record.service.spec.ts

@@ -1,107 +1,107 @@
-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 { OmniExternalRefEntity } from '../base/omni-external-ref.entity.js';
-import { OmniRecordStatus } from '../omni-record-status.enum.js';
-import { OmniRecordService } from '../omni-record.service.js';
-
-const scope = {
-  scopeId: 'scope-record-guard',
-  cacheKey: (key: string) => `scope-record-guard:${key}`,
-};
-const reservedKind = 'registered_extension';
-const ownerGuid = '10000000-0000-4000-8000-000000000301';
-const normalGuid = '10000000-0000-4000-8000-000000000302';
-
-describe('OmniRecordService extension owner guard', () => {
-  let dataSource: DataSource;
-  let service: InstanceType<typeof OmniRecordService>;
-
-  beforeEach(async () => {
-    dataSource = new DataSource({
-      type: 'sqlite',
-      database: ':memory:',
-      dropSchema: true,
-      synchronize: true,
-      entities: [
-        OmniNamedEntity,
-        OmniRecordEntity,
-        OmniRelationEntity,
-        OmniExternalRefEntity,
-      ],
-    });
-    await dataSource.initialize();
-    service = new OmniRecordService(
-      dataSource.getRepository(OmniRecordEntity) as never,
-      scope,
-      'tombstone',
-      [reservedKind],
-    );
-    await dataSource.getRepository(OmniRecordEntity).save({
-      scopeId: scope.scopeId,
-      guid: ownerGuid,
-      title: 'Extension-owned record',
-      kind: reservedKind,
-      status: OmniRecordStatus.Active,
-      payloadSchemaId: 'registered.extension.v1',
-      payloadSchemaVersion: 1,
-    });
-  });
-
-  afterEach(async () => {
-    await dataSource.destroy();
-  });
-
-  it('rejects generic creation, mutation, promotion, and deletion of a reserved extension owner', async () => {
-    await expect(
-      service.createEntity({
-        guid: '10000000-0000-4000-8000-000000000303',
-        title: 'Attempted extension owner',
-        kind: reservedKind,
-        status: OmniRecordStatus.Active,
-      }),
-    ).rejects.toThrow('owned by a registered extension projection');
-
-    await service.createEntity({
-      guid: normalGuid,
-      title: 'Normal record',
-      kind: 'normal_record',
-      status: OmniRecordStatus.Active,
-    });
-    await expect(
-      service.updateEntity(
-        { guid: normalGuid },
-        { kind: reservedKind },
-      ),
-    ).rejects.toThrow('owned by a registered extension projection');
-    await expect(
-      service.updateEntity(
-        { guid: ownerGuid },
-        { kind: 'normal_record' },
-      ),
-    ).rejects.toThrow('owned by a registered extension projection');
-    await expect(service.deleteEntity({ guid: ownerGuid })).rejects.toThrow(
-      'owned by a registered extension projection',
-    );
-
-    expect(
-      await dataSource.getRepository(OmniRecordEntity).findOneByOrFail({
-        scopeId: scope.scopeId,
-        guid: ownerGuid,
-      }),
-    ).toMatchObject({
-      kind: reservedKind,
-      payloadSchemaId: 'registered.extension.v1',
-      payloadSchemaVersion: 1,
-    });
-    expect(
-      await dataSource.getRepository(OmniRecordEntity).findOneByOrFail({
-        scopeId: scope.scopeId,
-        guid: normalGuid,
-      }),
-    ).toMatchObject({ kind: 'normal_record' });
-  });
-});
+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 { OmniExternalRefEntity } from '../base/omni-external-ref.entity.js';
+import { OmniRecordStatus } from '../omni-record-status.enum.js';
+import { OmniRecordService } from '../omni-record.service.js';
+
+const scope = {
+  scopeId: 'scope-record-guard',
+  cacheKey: (key: string) => `scope-record-guard:${key}`,
+};
+const reservedKind = 'registered_extension';
+const ownerGuid = '10000000-0000-4000-8000-000000000301';
+const normalGuid = '10000000-0000-4000-8000-000000000302';
+
+describe('OmniRecordService extension owner guard', () => {
+  let dataSource: DataSource;
+  let service: InstanceType<typeof OmniRecordService>;
+
+  beforeEach(async () => {
+    dataSource = new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      dropSchema: true,
+      synchronize: true,
+      entities: [
+        OmniNamedEntity,
+        OmniRecordEntity,
+        OmniRelationEntity,
+        OmniExternalRefEntity,
+      ],
+    });
+    await dataSource.initialize();
+    service = new OmniRecordService(
+      dataSource.getRepository(OmniRecordEntity) as never,
+      scope,
+      'tombstone',
+      [reservedKind],
+    );
+    await dataSource.getRepository(OmniRecordEntity).save({
+      scopeId: scope.scopeId,
+      guid: ownerGuid,
+      title: 'Extension-owned record',
+      kind: reservedKind,
+      status: OmniRecordStatus.Active,
+      payloadSchemaId: 'registered.extension.v1',
+      payloadSchemaVersion: 1,
+    });
+  });
+
+  afterEach(async () => {
+    await dataSource.destroy();
+  });
+
+  it('rejects generic creation, mutation, promotion, and deletion of a reserved extension owner', async () => {
+    await expect(
+      service.createEntity({
+        guid: '10000000-0000-4000-8000-000000000303',
+        title: 'Attempted extension owner',
+        kind: reservedKind,
+        status: OmniRecordStatus.Active,
+      }),
+    ).rejects.toThrow('owned by a registered extension projection');
+
+    await service.createEntity({
+      guid: normalGuid,
+      title: 'Normal record',
+      kind: 'normal_record',
+      status: OmniRecordStatus.Active,
+    });
+    await expect(
+      service.updateEntity(
+        { guid: normalGuid },
+        { kind: reservedKind },
+      ),
+    ).rejects.toThrow('owned by a registered extension projection');
+    await expect(
+      service.updateEntity(
+        { guid: ownerGuid },
+        { kind: 'normal_record' },
+      ),
+    ).rejects.toThrow('owned by a registered extension projection');
+    await expect(service.deleteEntity({ guid: ownerGuid })).rejects.toThrow(
+      'owned by a registered extension projection',
+    );
+
+    expect(
+      await dataSource.getRepository(OmniRecordEntity).findOneByOrFail({
+        scopeId: scope.scopeId,
+        guid: ownerGuid,
+      }),
+    ).toMatchObject({
+      kind: reservedKind,
+      payloadSchemaId: 'registered.extension.v1',
+      payloadSchemaVersion: 1,
+    });
+    expect(
+      await dataSource.getRepository(OmniRecordEntity).findOneByOrFail({
+        scopeId: scope.scopeId,
+        guid: normalGuid,
+      }),
+    ).toMatchObject({ kind: 'normal_record' });
+  });
+});

package/src/__tests__/omni-relation-semantics.spec.ts

@@ -1,102 +1,102 @@
-import { describe, expect, it } from '@jest/globals';
-
-import { OmniCollectionKind } from '../omni-collection-kind.enum.js';
-import { OmniDocumentKind } from '../omni-document-kind.enum.js';
-import { OmniRelationKind } from '../omni-relation-kind.enum.js';
-import {
-  OMNI_COLLECTION_MEMBERSHIP_RELATION_KIND,
-  isAllowedOmniRelation,
-  isCanonicalCollectionMembershipRelation,
-  isOmniCollectionRecordKind,
-  isOmniDocumentRecordKind,
-} from '../omni-relation-semantics.js';
-
-describe('Omni relation semantics', () => {
-  it('treats collection contains as the canonical collection membership edge', () => {
-    expect(OMNI_COLLECTION_MEMBERSHIP_RELATION_KIND).toBe(
-      OmniRelationKind.Contains,
-    );
-    expect(
-      isCanonicalCollectionMembershipRelation({
-        sourceKind: OmniCollectionKind.Collection,
-        relationKind: OmniRelationKind.Contains,
-      }),
-    ).toBe(true);
-    expect(
-      isCanonicalCollectionMembershipRelation({
-        sourceKind: OmniDocumentKind.Document,
-        relationKind: OmniRelationKind.Contains,
-      }),
-    ).toBe(false);
-  });
-
-  it('recognizes the current concrete record families', () => {
-    expect(isOmniCollectionRecordKind(OmniCollectionKind.Collection)).toBe(
-      true,
-    );
-    expect(isOmniCollectionRecordKind(OmniDocumentKind.Document)).toBe(false);
-    expect(isOmniDocumentRecordKind(OmniDocumentKind.Document)).toBe(true);
-    expect(isOmniDocumentRecordKind(OmniCollectionKind.Collection)).toBe(false);
-  });
-
-  it('allows collection-to-document contains links and rejects the reversed organization edge', () => {
-    expect(
-      isAllowedOmniRelation({
-        sourceKind: OmniCollectionKind.Collection,
-        targetKind: OmniDocumentKind.Document,
-        relationKind: OmniRelationKind.Contains,
-      }),
-    ).toBe(true);
-    expect(
-      isAllowedOmniRelation({
-        sourceKind: OmniDocumentKind.Document,
-        targetKind: OmniCollectionKind.Collection,
-        relationKind: OmniRelationKind.Contains,
-      }),
-    ).toBe(false);
-  });
-
-  it('limits derived_from to document lineage', () => {
-    expect(
-      isAllowedOmniRelation({
-        sourceKind: OmniDocumentKind.Document,
-        targetKind: OmniDocumentKind.Document,
-        relationKind: OmniRelationKind.DerivedFrom,
-      }),
-    ).toBe(true);
-    expect(
-      isAllowedOmniRelation({
-        sourceKind: OmniCollectionKind.Collection,
-        targetKind: OmniDocumentKind.Document,
-        relationKind: OmniRelationKind.DerivedFrom,
-      }),
-    ).toBe(false);
-  });
-
-  it('keeps references and related_to flexible for cross-record graph links', () => {
-    expect(
-      isAllowedOmniRelation({
-        sourceKind: OmniDocumentKind.Document,
-        targetKind: OmniCollectionKind.Collection,
-        relationKind: OmniRelationKind.References,
-      }),
-    ).toBe(true);
-    expect(
-      isAllowedOmniRelation({
-        sourceKind: OmniCollectionKind.Collection,
-        targetKind: OmniDocumentKind.Document,
-        relationKind: OmniRelationKind.RelatedTo,
-      }),
-    ).toBe(true);
-  });
-
-  it('returns false for unexpected relation values at runtime', () => {
-    expect(
-      isAllowedOmniRelation({
-        sourceKind: OmniCollectionKind.Collection,
-        targetKind: OmniDocumentKind.Document,
-        relationKind: 'unexpected' as OmniRelationKind,
-      }),
-    ).toBe(false);
-  });
-});
+import { describe, expect, it } from '@jest/globals';
+
+import { OmniCollectionKind } from '../omni-collection-kind.enum.js';
+import { OmniDocumentKind } from '../omni-document-kind.enum.js';
+import { OmniRelationKind } from '../omni-relation-kind.enum.js';
+import {
+  OMNI_COLLECTION_MEMBERSHIP_RELATION_KIND,
+  isAllowedOmniRelation,
+  isCanonicalCollectionMembershipRelation,
+  isOmniCollectionRecordKind,
+  isOmniDocumentRecordKind,
+} from '../omni-relation-semantics.js';
+
+describe('Omni relation semantics', () => {
+  it('treats collection contains as the canonical collection membership edge', () => {
+    expect(OMNI_COLLECTION_MEMBERSHIP_RELATION_KIND).toBe(
+      OmniRelationKind.Contains,
+    );
+    expect(
+      isCanonicalCollectionMembershipRelation({
+        sourceKind: OmniCollectionKind.Collection,
+        relationKind: OmniRelationKind.Contains,
+      }),
+    ).toBe(true);
+    expect(
+      isCanonicalCollectionMembershipRelation({
+        sourceKind: OmniDocumentKind.Document,
+        relationKind: OmniRelationKind.Contains,
+      }),
+    ).toBe(false);
+  });
+
+  it('recognizes the current concrete record families', () => {
+    expect(isOmniCollectionRecordKind(OmniCollectionKind.Collection)).toBe(
+      true,
+    );
+    expect(isOmniCollectionRecordKind(OmniDocumentKind.Document)).toBe(false);
+    expect(isOmniDocumentRecordKind(OmniDocumentKind.Document)).toBe(true);
+    expect(isOmniDocumentRecordKind(OmniCollectionKind.Collection)).toBe(false);
+  });
+
+  it('allows collection-to-document contains links and rejects the reversed organization edge', () => {
+    expect(
+      isAllowedOmniRelation({
+        sourceKind: OmniCollectionKind.Collection,
+        targetKind: OmniDocumentKind.Document,
+        relationKind: OmniRelationKind.Contains,
+      }),
+    ).toBe(true);
+    expect(
+      isAllowedOmniRelation({
+        sourceKind: OmniDocumentKind.Document,
+        targetKind: OmniCollectionKind.Collection,
+        relationKind: OmniRelationKind.Contains,
+      }),
+    ).toBe(false);
+  });
+
+  it('limits derived_from to document lineage', () => {
+    expect(
+      isAllowedOmniRelation({
+        sourceKind: OmniDocumentKind.Document,
+        targetKind: OmniDocumentKind.Document,
+        relationKind: OmniRelationKind.DerivedFrom,
+      }),
+    ).toBe(true);
+    expect(
+      isAllowedOmniRelation({
+        sourceKind: OmniCollectionKind.Collection,
+        targetKind: OmniDocumentKind.Document,
+        relationKind: OmniRelationKind.DerivedFrom,
+      }),
+    ).toBe(false);
+  });
+
+  it('keeps references and related_to flexible for cross-record graph links', () => {
+    expect(
+      isAllowedOmniRelation({
+        sourceKind: OmniDocumentKind.Document,
+        targetKind: OmniCollectionKind.Collection,
+        relationKind: OmniRelationKind.References,
+      }),
+    ).toBe(true);
+    expect(
+      isAllowedOmniRelation({
+        sourceKind: OmniCollectionKind.Collection,
+        targetKind: OmniDocumentKind.Document,
+        relationKind: OmniRelationKind.RelatedTo,
+      }),
+    ).toBe(true);
+  });
+
+  it('returns false for unexpected relation values at runtime', () => {
+    expect(
+      isAllowedOmniRelation({
+        sourceKind: OmniCollectionKind.Collection,
+        targetKind: OmniDocumentKind.Document,
+        relationKind: 'unexpected' as OmniRelationKind,
+      }),
+    ).toBe(false);
+  });
+});

package/src/__tests__/omni-relation.entity.spec.ts

@@ -1,38 +1,38 @@
-import { describe, expect, it } from '@jest/globals';
-import { getMetadataArgsStorage } from 'typeorm';
-
-import { OmniBaseEntity } from '../base/omni-base.entity.js';
-import { OmniRelationEntity } from '../base/omni-relation.entity.js';
-
-describe('OmniRelationEntity', () => {
-  it('extends OmniBaseEntity', () => {
-    expect(new OmniRelationEntity()).toBeInstanceOf(OmniBaseEntity);
-  });
-
-  it('registers the record linkage columns and relations', () => {
-    const metadata = getMetadataArgsStorage();
-    const table = metadata.tables.find(
-      (item) => item.target === OmniRelationEntity,
-    );
-    const entityColumns = metadata.columns
-      .filter((item) => item.target === OmniRelationEntity)
-      .map((item) => item.propertyName);
-    const relations = metadata.relations
-      .filter((item) => item.target === OmniRelationEntity)
-      .map((item) => item.propertyName);
-
-    expect(table?.name).toBe('omni-relation');
-    expect(entityColumns).toEqual(
-      expect.arrayContaining([
-        'sourceRecordId',
-        'targetRecordId',
-        'kind',
-        'status',
-        'payload',
-      ]),
-    );
-    expect(relations).toEqual(
-      expect.arrayContaining(['sourceRecord', 'targetRecord']),
-    );
-  });
-});
+import { describe, expect, it } from '@jest/globals';
+import { getMetadataArgsStorage } from 'typeorm';
+
+import { OmniBaseEntity } from '../base/omni-base.entity.js';
+import { OmniRelationEntity } from '../base/omni-relation.entity.js';
+
+describe('OmniRelationEntity', () => {
+  it('extends OmniBaseEntity', () => {
+    expect(new OmniRelationEntity()).toBeInstanceOf(OmniBaseEntity);
+  });
+
+  it('registers the record linkage columns and relations', () => {
+    const metadata = getMetadataArgsStorage();
+    const table = metadata.tables.find(
+      (item) => item.target === OmniRelationEntity,
+    );
+    const entityColumns = metadata.columns
+      .filter((item) => item.target === OmniRelationEntity)
+      .map((item) => item.propertyName);
+    const relations = metadata.relations
+      .filter((item) => item.target === OmniRelationEntity)
+      .map((item) => item.propertyName);
+
+    expect(table?.name).toBe('omni-relation');
+    expect(entityColumns).toEqual(
+      expect.arrayContaining([
+        'sourceRecordId',
+        'targetRecordId',
+        'kind',
+        'status',
+        'payload',
+      ]),
+    );
+    expect(relations).toEqual(
+      expect.arrayContaining(['sourceRecord', 'targetRecord']),
+    );
+  });
+});