@nest-yalc-2/omnikernel-module 1.1.0

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

@@ -0,0 +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);
+  });
+});

package/src/__tests__/omnikernel.public-api.spec.ts

@@ -0,0 +1,238 @@
+import { describe, expect, it } from '@jest/globals';
+import 'reflect-metadata';
+import { OmniCollectionKind } from '../omni-collection-kind.enum.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';
+
+import * as namedDto from '../omni-named.dto.js';
+import * as recordDto from '../omni-record.dto.js';
+import * as collectionDto from '../omni-collection.dto.js';
+import * as relationDto from '../omni-relation.dto.js';
+import * as externalRefDto from '../omni-external-ref.dto.js';
+import * as documentDto from '../omni-document.dto.js';
+import { OmniCollectionEntity } from '../omni-collection.entity.js';
+import { OmniCollectionService } from '../omni-collection.service.js';
+import { OmniDocumentEntity } from '../omni-document.entity.js';
+import { OmniDocumentService } from '../omni-document.service.js';
+import { OmniExternalRefInternalType } from '../omni-external-ref-internal-type.enum.js';
+import { OmniExternalRefService } from '../omni-external-ref.service.js';
+import * as relationSemantics from '../omni-relation-semantics.js';
+import { OmniKernelQueryService } from '../omnikernel.query.service.js';
+import { omniCollectionBackendProvidersFactory } from '../omni-collection.backend.js';
+import { omniNamedBackendProvidersFactory } from '../omni-named.backend.js';
+import { omniRecordBackendProvidersFactory } from '../omni-record.backend.js';
+import { omniRelationBackendProvidersFactory } from '../omni-relation.backend.js';
+import { omniExternalRefBackendProvidersFactory } from '../omni-external-ref.backend.js';
+import { omniDocumentBackendProvidersFactory } from '../omni-document.backend.js';
+import * as omnikernelPublicApi from '../index.js';
+
+describe('OmniKernel public API', () => {
+  it('copies data through DTO constructors', () => {
+    const named = new namedDto.OmniNamedType({
+      guid: '6c1bfae7-b56c-4537-a5c7-98c84ce2d23a',
+      title: 'Named',
+      slug: 'named',
+    });
+    const record = new recordDto.OmniRecordType({
+      guid: 'b7df87c7-b8b8-43a3-99c0-811024a48b39',
+      title: 'Record',
+      kind: 'generic',
+      status: OmniRecordStatus.Active,
+      payload: { ok: true },
+    });
+    const collection = new collectionDto.OmniCollectionType({
+      guid: '0f7f6978-66f2-4d96-a7f3-a0ecf399f2e2',
+      title: 'Collection',
+      kind: OmniCollectionKind.Collection,
+      status: OmniRecordStatus.Active,
+      collectionKind: OmniCollectionKind.Folder,
+      summary: 'Container',
+    });
+    const relation = new relationDto.OmniRelationType({
+      guid: '5bba1944-1a52-4918-ba54-453e09d3d9b3',
+      sourceRecordId: 'b7df87c7-b8b8-43a3-99c0-811024a48b39',
+      targetRecordId: '6c1bfae7-b56c-4537-a5c7-98c84ce2d23a',
+      kind: OmniRelationKind.Contains,
+      status: OmniRelationStatus.Active,
+    });
+    const externalRef = new externalRefDto.OmniExternalRefType({
+      guid: '47eaf320-9fbe-4f2e-9a0a-c2c4cbdb2d9e',
+      internalType: OmniExternalRefInternalType.Document,
+      internalId: 'b7df87c7-b8b8-43a3-99c0-811024a48b39',
+      provider: 'github',
+      externalId: '123',
+    });
+    const document = new documentDto.OmniDocumentType({
+      guid: 'ebf2fd92-9271-4cb7-b5a8-a7ce0105dff5',
+      title: 'Document',
+      kind: OmniDocumentKind.Document,
+      status: OmniRecordStatus.Active,
+      documentKind: OmniDocumentKind.Document,
+      content: 'Body',
+    });
+
+    expect(named.title).toBe('Named');
+    expect(record.payload).toEqual({ ok: true });
+    expect(collection.collectionKind).toBe(OmniCollectionKind.Folder);
+    expect(relation.kind).toBe(OmniRelationKind.Contains);
+    expect(externalRef.provider).toBe('github');
+    expect(document.documentKind).toBe(OmniDocumentKind.Document);
+  });
+
+  it('exposes generated GraphQL input types', () => {
+    expect(new namedDto.OmniNamedCreateInput()).toBeInstanceOf(
+      namedDto.OmniNamedCreateInput,
+    );
+    expect(new namedDto.OmniNamedCondition()).toBeInstanceOf(
+      namedDto.OmniNamedCondition,
+    );
+    expect(new namedDto.OmniNamedUpdateInput()).toBeInstanceOf(
+      namedDto.OmniNamedUpdateInput,
+    );
+
+    expect(new recordDto.OmniRecordCreateInput()).toBeInstanceOf(
+      recordDto.OmniRecordCreateInput,
+    );
+    expect(new recordDto.OmniRecordCondition()).toBeInstanceOf(
+      recordDto.OmniRecordCondition,
+    );
+    expect(new recordDto.OmniRecordUpdateInput()).toBeInstanceOf(
+      recordDto.OmniRecordUpdateInput,
+    );
+
+    expect(new collectionDto.OmniCollectionCreateInput()).toBeInstanceOf(
+      collectionDto.OmniCollectionCreateInput,
+    );
+    expect(new collectionDto.OmniCollectionCondition()).toBeInstanceOf(
+      collectionDto.OmniCollectionCondition,
+    );
+    expect(new collectionDto.OmniCollectionUpdateInput()).toBeInstanceOf(
+      collectionDto.OmniCollectionUpdateInput,
+    );
+
+    expect(new relationDto.OmniRelationCreateInput()).toBeInstanceOf(
+      relationDto.OmniRelationCreateInput,
+    );
+    expect(new relationDto.OmniRelationCondition()).toBeInstanceOf(
+      relationDto.OmniRelationCondition,
+    );
+    expect(new relationDto.OmniRelationUpdateInput()).toBeInstanceOf(
+      relationDto.OmniRelationUpdateInput,
+    );
+
+    expect(new externalRefDto.OmniExternalRefCreateInput()).toBeInstanceOf(
+      externalRefDto.OmniExternalRefCreateInput,
+    );
+    expect(new externalRefDto.OmniExternalRefCondition()).toBeInstanceOf(
+      externalRefDto.OmniExternalRefCondition,
+    );
+    expect(new externalRefDto.OmniExternalRefUpdateInput()).toBeInstanceOf(
+      externalRefDto.OmniExternalRefUpdateInput,
+    );
+
+    expect(new documentDto.OmniDocumentCreateInput()).toBeInstanceOf(
+      documentDto.OmniDocumentCreateInput,
+    );
+    expect(new documentDto.OmniDocumentCondition()).toBeInstanceOf(
+      documentDto.OmniDocumentCondition,
+    );
+    expect(new documentDto.OmniDocumentUpdateInput()).toBeInstanceOf(
+      documentDto.OmniDocumentUpdateInput,
+    );
+  });
+
+  it('builds backend provider configs for every public backend factory', () => {
+    const named = omniNamedBackendProvidersFactory('db');
+    const record = omniRecordBackendProvidersFactory('db');
+    const collection = omniCollectionBackendProvidersFactory('db');
+    const relation = omniRelationBackendProvidersFactory('db');
+    const externalRef = omniExternalRefBackendProvidersFactory('db');
+    const document = omniDocumentBackendProvidersFactory('db');
+
+    expect(named.repository).toBeDefined();
+    expect(record.repository).toBeDefined();
+    expect(collection.repository).toBeDefined();
+    expect(relation.repository).toBeDefined();
+    expect(externalRef.repository).toBeDefined();
+    expect(document.repository).toBeDefined();
+    expect(record.providers.length).toBeGreaterThan(0);
+    expect(collection.providers.length).toBeGreaterThan(0);
+    expect(document.providers.length).toBeGreaterThan(0);
+    expect(
+      collection.providers.some(
+        (provider) =>
+          typeof provider === 'object' &&
+          provider !== null &&
+          'provide' in provider &&
+          provider.provide === OmniCollectionService,
+      ),
+    ).toBe(true);
+    expect(
+      document.providers.some(
+        (provider) =>
+          typeof provider === 'object' &&
+          provider !== null &&
+          'provide' in provider &&
+          provider.provide === OmniDocumentService,
+        ),
+    ).toBe(true);
+    expect(
+      externalRef.providers.some(
+        (provider) =>
+          typeof provider === 'object' &&
+          provider !== null &&
+          'provide' in provider &&
+          provider.provide === OmniExternalRefService,
+      ),
+    ).toBe(true);
+    expect(OmniCollectionEntity).toBe(omnikernelPublicApi.OmniCollectionEntity);
+    expect(OmniDocumentEntity).toBe(omnikernelPublicApi.OmniDocumentEntity);
+  });
+
+  it('re-exports the documented OmniKernel surface from index.ts', () => {
+    expect(omnikernelPublicApi.OmniKernelModule).toBeDefined();
+    expect(omnikernelPublicApi.OmniNamedType).toBe(namedDto.OmniNamedType);
+    expect(omnikernelPublicApi.OmniRecordType).toBe(recordDto.OmniRecordType);
+    expect(omnikernelPublicApi.OmniCollectionType).toBe(
+      collectionDto.OmniCollectionType,
+    );
+    expect(omnikernelPublicApi.OmniRelationType).toBe(
+      relationDto.OmniRelationType,
+    );
+    expect(omnikernelPublicApi.OmniExternalRefType).toBe(
+      externalRefDto.OmniExternalRefType,
+    );
+    expect(omnikernelPublicApi.OmniDocumentType).toBe(
+      documentDto.OmniDocumentType,
+    );
+    expect(omnikernelPublicApi.omniDocumentBackendProvidersFactory).toBe(
+      omniDocumentBackendProvidersFactory,
+    );
+    expect(omnikernelPublicApi.omniCollectionBackendProvidersFactory).toBe(
+      omniCollectionBackendProvidersFactory,
+    );
+    expect(omnikernelPublicApi.omniNamedBackendProvidersFactory).toBe(
+      omniNamedBackendProvidersFactory,
+    );
+    expect(omnikernelPublicApi.omniRecordBackendProvidersFactory).toBe(
+      omniRecordBackendProvidersFactory,
+    );
+    expect(omnikernelPublicApi.omniRelationBackendProvidersFactory).toBe(
+      omniRelationBackendProvidersFactory,
+    );
+    expect(omnikernelPublicApi.omniExternalRefBackendProvidersFactory).toBe(
+      omniExternalRefBackendProvidersFactory,
+    );
+    expect(omnikernelPublicApi.isAllowedOmniRelation).toBe(
+      relationSemantics.isAllowedOmniRelation,
+    );
+    expect(omnikernelPublicApi.OmniExternalRefInternalType).toBe(
+      OmniExternalRefInternalType,
+    );
+    expect(omnikernelPublicApi.OmniKernelQueryService).toBe(
+      OmniKernelQueryService,
+    );
+  });
+});

package/src/__tests__/omnikernel.query.service.spec.ts

@@ -0,0 +1,155 @@
+import { describe, expect, it, jest } from "@jest/globals";
+
+import { OmniCollectionKind } from '../omni-collection-kind.enum.js';
+import { OmniDocumentKind } from '../omni-document-kind.enum.js';
+import { OmniExternalRefInternalType } from '../omni-external-ref-internal-type.enum.js';
+import { OmniKernelQueryService } from '../omnikernel.query.service.js';
+
+describe("OmniKernelQueryService", () => {
+  it("returns collection members from canonical contains relations", async () => {
+    const relationRepository = {
+      find: jest.fn(async () => [
+        {
+          targetRecord: {
+            guid: "doc-1",
+            kind: OmniDocumentKind.Document,
+          },
+        },
+      ]),
+    };
+    const externalRefRepository = {
+      find: jest.fn(),
+    };
+    const service = new OmniKernelQueryService(
+      relationRepository as never,
+      externalRefRepository as never,
+    );
+
+    const result = await service.getCollectionMembers("collection-1");
+
+    expect(relationRepository.find).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          sourceRecordId: "collection-1",
+        }),
+      }),
+    );
+    expect(result).toEqual([
+      {
+        guid: "doc-1",
+        kind: OmniDocumentKind.Document,
+      },
+    ]);
+  });
+
+  it("returns parent collections for a document through inverse contains relations", async () => {
+    const relationRepository = {
+      find: jest.fn(async () => [
+        {
+          sourceRecord: {
+            guid: "collection-1",
+            kind: OmniCollectionKind.Collection,
+          },
+        },
+      ]),
+    };
+    const externalRefRepository = {
+      find: jest.fn(),
+    };
+    const service = new OmniKernelQueryService(
+      relationRepository as never,
+      externalRefRepository as never,
+    );
+
+    const result = await service.getDocumentCollections("doc-1");
+
+    expect(relationRepository.find).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({
+          targetRecordId: "doc-1",
+        }),
+      }),
+    );
+    expect(result).toEqual([
+      {
+        guid: "collection-1",
+        kind: OmniCollectionKind.Collection,
+      },
+    ]);
+  });
+
+  it("filters out inverse contains sources that are not collections", async () => {
+    const relationRepository = {
+      find: jest.fn(async () => [
+        {
+          sourceRecord: {
+            guid: "collection-1",
+            kind: OmniCollectionKind.Collection,
+          },
+        },
+        {
+          sourceRecord: {
+            guid: "doc-2",
+            kind: OmniDocumentKind.Document,
+          },
+        },
+      ]),
+    };
+    const externalRefRepository = {
+      find: jest.fn(),
+    };
+    const service = new OmniKernelQueryService(
+      relationRepository as never,
+      externalRefRepository as never,
+    );
+
+    const result = await service.getDocumentCollections("doc-1");
+
+    expect(result).toEqual([
+      {
+        guid: "collection-1",
+        kind: OmniCollectionKind.Collection,
+      },
+    ]);
+  });
+
+  it("returns document external refs through the query layer", async () => {
+    const relationRepository = {
+      find: jest.fn(),
+    };
+    const externalRefRepository = {
+      find: jest.fn(async () => [
+        {
+          guid: "ref-1",
+          internalType: OmniExternalRefInternalType.Document,
+          internalId: "doc-1",
+        },
+      ]),
+    };
+    const service = new OmniKernelQueryService(
+      relationRepository as never,
+      externalRefRepository as never,
+    );
+
+    const result = await service.getDocumentExternalRefs("doc-1", "github");
+
+    expect(externalRefRepository.find).toHaveBeenCalledWith({
+      where: {
+        scopeId: "default",
+        internalType: OmniExternalRefInternalType.Document,
+        internalId: "doc-1",
+        provider: "github",
+      },
+      order: {
+        createdAt: "ASC",
+      },
+    });
+    expect(result).toEqual([
+      {
+        guid: "ref-1",
+        internalType: OmniExternalRefInternalType.Document,
+        internalId: "doc-1",
+      },
+    ]);
+  });
+});

package/src/__tests__/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "../../../../../tsconfig.test.json",
+  "compilerOptions": {
+    "rootDir": "../../../../../"
+  }
+}

package/src/base/omni-base.entity.d.ts

@@ -0,0 +1,9 @@
+import { BaseEntity } from 'typeorm';
+export declare abstract class OmniBaseEntity extends BaseEntity {
+    scopeId: string;
+    guid: string;
+    revision: number;
+    deletedAt?: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}

package/src/base/omni-base.entity.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmniBaseEntity = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const typeorm_1 = require("typeorm");
+let OmniBaseEntity = class OmniBaseEntity extends typeorm_1.BaseEntity {
+    constructor() {
+        super(...arguments);
+        this.scopeId = 'default';
+    }
+};
+exports.OmniBaseEntity = OmniBaseEntity;
+__decorate([
+    (0, typeorm_1.PrimaryColumn)('varchar', {
+        name: 'scopeId',
+        length: 64,
+        default: 'default',
+    }),
+    __metadata("design:type", String)
+], OmniBaseEntity.prototype, "scopeId", void 0);
+__decorate([
+    (0, typeorm_1.PrimaryColumn)('varchar', { name: 'guid', length: 36 }),
+    __metadata("design:type", String)
+], OmniBaseEntity.prototype, "guid", void 0);
+__decorate([
+    (0, typeorm_1.VersionColumn)({ type: 'integer', default: 1 }),
+    __metadata("design:type", Number)
+], OmniBaseEntity.prototype, "revision", void 0);
+__decorate([
+    (0, typeorm_1.DeleteDateColumn)({ nullable: true }),
+    __metadata("design:type", Object)
+], OmniBaseEntity.prototype, "deletedAt", void 0);
+__decorate([
+    (0, typeorm_1.CreateDateColumn)(),
+    __metadata("design:type", Date)
+], OmniBaseEntity.prototype, "createdAt", void 0);
+__decorate([
+    (0, typeorm_1.UpdateDateColumn)(),
+    __metadata("design:type", Date)
+], OmniBaseEntity.prototype, "updatedAt", void 0);
+exports.OmniBaseEntity = OmniBaseEntity = __decorate([
+    (0, graphql_1.ObjectType)({ isAbstract: true })
+], OmniBaseEntity);
+//# sourceMappingURL=omni-base.entity.js.map

package/src/base/omni-base.entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omni-base.entity.js","sourceRoot":"","sources":["omni-base.entity.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,6CAA6C;AAC7C,qCAOiB;AAGV,IAAe,cAAc,GAA7B,MAAe,cAAe,SAAQ,oBAAU;IAAhD;;QAWL,YAAO,GAAW,SAAS,CAAC;IAkB9B,CAAC;CAAA,CAAA;AA7BqB,wCAAc;AAWlC;IALC,IAAA,uBAAa,EAAC,SAAS,EAAE;QACxB,IAAI,EAAE,SAAS;QACf,MAAM,EAAE,EAAE;QACV,OAAO,EAAE,SAAS;KACnB,CAAC;;+CAC0B;AAG5B;IADC,IAAA,uBAAa,EAAC,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;;4CACzC;AAId;IADC,IAAA,uBAAa,EAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;;gDAC7B;AAIlB;IADC,IAAA,0BAAgB,EAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;;iDACb;AAGxB;IADC,IAAA,0BAAgB,GAAE;8BACP,IAAI;iDAAC;AAGjB;IADC,IAAA,0BAAgB,GAAE;8BACP,IAAI;iDAAC;yBA5BG,cAAc;IADnC,IAAA,oBAAU,EAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;GACX,cAAc,CA6BnC"}

package/src/base/omni-base.entity.ts

@@ -0,0 +1,41 @@
+import { ObjectType } from '@nestjs/graphql';
+import {
+  BaseEntity,
+  CreateDateColumn,
+  DeleteDateColumn,
+  PrimaryColumn,
+  UpdateDateColumn,
+  VersionColumn,
+} from 'typeorm';
+
+@ObjectType({ isAbstract: true })
+export abstract class OmniBaseEntity extends BaseEntity {
+  /**
+   * The server-owned partition key. It is never represented by the public
+   * CRUD DTOs. Together with guid it is the composite primary identity, which
+   * lets the same logical GUID exist in independent server-owned partitions.
+   */
+  @PrimaryColumn('varchar', {
+    name: 'scopeId',
+    length: 64,
+    default: 'default',
+  })
+  scopeId: string = 'default';
+
+  @PrimaryColumn('varchar', { name: 'guid', length: 36 })
+  guid!: string;
+
+  /** Server-managed optimistic version for ordinary Omni updates. */
+  @VersionColumn({ type: 'integer', default: 1 })
+  revision!: number;
+
+  /** Present only for resources configured with the tombstone lifecycle. */
+  @DeleteDateColumn({ nullable: true })
+  deletedAt?: Date | null;
+
+  @CreateDateColumn()
+  createdAt!: Date;
+
+  @UpdateDateColumn()
+  updatedAt!: Date;
+}

package/src/base/omni-external-ref.entity.d.ts

@@ -0,0 +1,13 @@
+import { OmniBaseEntity } from './omni-base.entity.js';
+import { OmniExternalRefInternalType } from '../omni-external-ref-internal-type.enum.js';
+export declare class OmniExternalRefEntity extends OmniBaseEntity {
+    internalType: OmniExternalRefInternalType;
+    internalId: string;
+    provider: string;
+    account?: string | null;
+    container?: string | null;
+    externalId: string;
+    payload?: Record<string, unknown> | null;
+    payloadSchemaId?: string | null;
+    payloadSchemaVersion?: number | null;
+}