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

package/src/__tests__/omni-external-ref.entity.spec.ts

@@ -1,36 +1,36 @@
-import { describe, expect, it } from '@jest/globals';
-import { getMetadataArgsStorage } from 'typeorm';
-
-import { OmniBaseEntity } from '../base/omni-base.entity.js';
-import {
-  OmniExternalRefEntity,
-} from '../base/omni-external-ref.entity.js';
-
-describe('OmniExternalRefEntity', () => {
-  it('extends OmniBaseEntity', () => {
-    expect(new OmniExternalRefEntity()).toBeInstanceOf(OmniBaseEntity);
-  });
-
-  it('registers external mapping columns', () => {
-    const metadata = getMetadataArgsStorage();
-    const table = metadata.tables.find(
-      (item) => item.target === OmniExternalRefEntity,
-    );
-    const entityColumns = metadata.columns
-      .filter((item) => item.target === OmniExternalRefEntity)
-      .map((item) => item.propertyName);
-
-    expect(table?.name).toBe('omni-external-ref');
-    expect(entityColumns).toEqual(
-      expect.arrayContaining([
-        'internalType',
-        'internalId',
-        'provider',
-        'account',
-        'container',
-        'externalId',
-        'payload',
-      ]),
-    );
-  });
-});
+import { describe, expect, it } from '@jest/globals';
+import { getMetadataArgsStorage } from 'typeorm';
+
+import { OmniBaseEntity } from '../base/omni-base.entity.js';
+import {
+  OmniExternalRefEntity,
+} from '../base/omni-external-ref.entity.js';
+
+describe('OmniExternalRefEntity', () => {
+  it('extends OmniBaseEntity', () => {
+    expect(new OmniExternalRefEntity()).toBeInstanceOf(OmniBaseEntity);
+  });
+
+  it('registers external mapping columns', () => {
+    const metadata = getMetadataArgsStorage();
+    const table = metadata.tables.find(
+      (item) => item.target === OmniExternalRefEntity,
+    );
+    const entityColumns = metadata.columns
+      .filter((item) => item.target === OmniExternalRefEntity)
+      .map((item) => item.propertyName);
+
+    expect(table?.name).toBe('omni-external-ref');
+    expect(entityColumns).toEqual(
+      expect.arrayContaining([
+        'internalType',
+        'internalId',
+        'provider',
+        'account',
+        'container',
+        'externalId',
+        'payload',
+      ]),
+    );
+  });
+});

package/src/__tests__/omni-external-ref.service.spec.ts

@@ -1,252 +1,252 @@
-import { describe, expect, it, jest } from "@jest/globals";
-
-import { OmniExternalRefService } from '../omni-external-ref.service.js';
-import { OmniExternalRefEntity } from '../base/omni-external-ref.entity.js';
-import { OmniExternalRefInternalType } from '../omni-external-ref-internal-type.enum.js';
-
-const bindingValidator = {
-  assertTarget: jest.fn(async () => ({})),
-};
-
-const createRepositoryPair = () => {
-  const readRepository = {
-    target: OmniExternalRefEntity,
-    findOne: jest.fn(),
-    find: jest.fn(),
-    findOneOrFail: jest.fn(),
-    getId: jest.fn((entity: OmniExternalRefEntity) => ({ guid: entity.guid })),
-  };
-  const writeRepository = {
-    target: OmniExternalRefEntity,
-    create: jest.fn((input: unknown) => input),
-    insert: jest.fn(async () => ({
-      identifiers: [{ guid: "eeeeeeee-1111-1111-1111-111111111111" }],
-    })),
-    update: jest.fn(async () => ({ affected: 1 })),
-  };
-
-  return { readRepository, writeRepository };
-};
-
-describe("OmniExternalRefService", () => {
-  it('requires a binding validator instead of silently bypassing target validation', () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-
-    expect(
-      () =>
-        new OmniExternalRefService(
-          readRepository as never,
-          writeRepository as never,
-          'hard',
-          undefined as never,
-        ),
-    ).toThrow('requires an OmniExternalRefBindingValidator');
-  });
-
-  it("looks up references by provider/external identity", async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    const service = new OmniExternalRefService(
-      readRepository as never,
-      writeRepository as never,
-      'hard',
-      bindingValidator as never,
-    );
-
-    await service.findByExternalIdentity({
-      provider: "github",
-      externalId: "123",
-      account: "acme",
-      container: "kb",
-    });
-
-    expect(readRepository.findOne).toHaveBeenCalledWith({
-      where: {
-        scopeId: "default",
-        provider: "github",
-        externalId: "123",
-        account: "acme",
-        container: "kb",
-      },
-    });
-  });
-
-  it("returns all references for an internal record", async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    const service = new OmniExternalRefService(
-      readRepository as never,
-      writeRepository as never,
-      'hard',
-      bindingValidator as never,
-    );
-
-    await service.findForInternalRecord(
-      OmniExternalRefInternalType.Document,
-      "doc-1",
-      "github",
-    );
-
-    expect(readRepository.find).toHaveBeenCalledWith({
-      where: {
-        scopeId: "default",
-        internalType: OmniExternalRefInternalType.Document,
-        internalId: "doc-1",
-        provider: "github",
-      },
-      order: {
-        createdAt: "ASC",
-      },
-    });
-  });
-
-  it("creates a new external ref when the identity does not exist", async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    readRepository.findOne.mockResolvedValue(null);
-    const service = new OmniExternalRefService(
-      readRepository as never,
-      writeRepository as never,
-      'hard',
-      bindingValidator as never,
-    );
-    const createSpy = jest
-      .spyOn(service, "createEntity")
-      .mockResolvedValue({ guid: "created" } as OmniExternalRefEntity);
-
-    const result = await service.upsertExternalRef({
-      internalType: OmniExternalRefInternalType.Document,
-      internalId: "doc-1",
-      provider: "github",
-      externalId: "123",
-    });
-
-    expect(createSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        internalType: OmniExternalRefInternalType.Document,
-        internalId: "doc-1",
-      }),
-    );
-    expect(result.guid).toBe("created");
-  });
-
-  it("validates record bindings without changing legacy non-record bindings", async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    readRepository.findOne.mockResolvedValue(null);
-    const validator = {
-      assertTarget: jest.fn(async () => ({})),
-    };
-    const service = new OmniExternalRefService(
-      readRepository as never,
-      writeRepository as never,
-      "hard",
-      validator as never,
-    );
-
-    await service.createEntity({
-      guid: "eeeeeeee-1111-1111-1111-111111111112",
-      provider: "example",
-      externalId: "record",
-      internalType: OmniExternalRefInternalType.Record,
-      internalId: "aaaaaaaa-1111-1111-1111-111111111111",
-    });
-    expect(validator.assertTarget).toHaveBeenCalledWith({
-      internalType: OmniExternalRefInternalType.Record,
-      internalId: "aaaaaaaa-1111-1111-1111-111111111111",
-    });
-
-    await service.createEntity({
-      guid: "eeeeeeee-1111-1111-1111-111111111113",
-      provider: "example",
-      externalId: "legacy-document",
-      internalType: OmniExternalRefInternalType.Document,
-      internalId: "aaaaaaaa-1111-1111-1111-111111111112",
-    });
-    expect(validator.assertTarget).toHaveBeenCalledTimes(1);
-  });
-
-  it("updates an existing external ref when the identity already exists", async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    readRepository.findOne.mockResolvedValue({
-      guid: "existing-guid",
-      internalType: OmniExternalRefInternalType.Document,
-      internalId: "doc-1",
-    });
-    const service = new OmniExternalRefService(
-      readRepository as never,
-      writeRepository as never,
-      'hard',
-      bindingValidator as never,
-    );
-    const updateSpy = jest
-      .spyOn(service, "updateEntity")
-      .mockResolvedValue({ guid: "existing-guid" } as OmniExternalRefEntity);
-
-    const result = await service.upsertExternalRef({
-      internalType: OmniExternalRefInternalType.Document,
-      internalId: "doc-1",
-      provider: "github",
-      externalId: "123",
-      payload: { synced: true },
-    });
-
-    expect(updateSpy).toHaveBeenCalledWith(
-      { guid: "existing-guid" },
-      expect.objectContaining({
-        payload: { synced: true },
-      }),
-    );
-    expect(result.guid).toBe("existing-guid");
-  });
-
-  it("rejects blank provider or external identity during upsert", async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    const service = new OmniExternalRefService(
-      readRepository as never,
-      writeRepository as never,
-      'hard',
-      bindingValidator as never,
-    );
-
-    await expect(
-      service.upsertExternalRef({
-        internalType: OmniExternalRefInternalType.Document,
-        internalId: "doc-1",
-        provider: "",
-        externalId: "123",
-      }),
-    ).rejects.toThrow("OmniExternalRef.provider is required");
-
-    await expect(
-      service.upsertExternalRef({
-        internalType: OmniExternalRefInternalType.Document,
-        internalId: "doc-1",
-        provider: "github",
-        externalId: "   ",
-      }),
-    ).rejects.toThrow("OmniExternalRef.externalId is required");
-  });
-
-  it("syncs document references with the document internal type", async () => {
-    const { readRepository, writeRepository } = createRepositoryPair();
-    const service = new OmniExternalRefService(
-      readRepository as never,
-      writeRepository as never,
-      'hard',
-      bindingValidator as never,
-    );
-    const upsertSpy = jest
-      .spyOn(service, "upsertExternalRef")
-      .mockResolvedValue({ guid: "doc-ref" } as OmniExternalRefEntity);
-
-    await service.syncDocumentReference("doc-1", {
-      provider: "github",
-      externalId: "123",
-      account: "acme",
-    });
-
-    expect(upsertSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        internalType: OmniExternalRefInternalType.Document,
-        internalId: "doc-1",
-      }),
-    );
-  });
-});
+import { describe, expect, it, jest } from "@jest/globals";
+
+import { OmniExternalRefService } from '../omni-external-ref.service.js';
+import { OmniExternalRefEntity } from '../base/omni-external-ref.entity.js';
+import { OmniExternalRefInternalType } from '../omni-external-ref-internal-type.enum.js';
+
+const bindingValidator = {
+  assertTarget: jest.fn(async () => ({})),
+};
+
+const createRepositoryPair = () => {
+  const readRepository = {
+    target: OmniExternalRefEntity,
+    findOne: jest.fn(),
+    find: jest.fn(),
+    findOneOrFail: jest.fn(),
+    getId: jest.fn((entity: OmniExternalRefEntity) => ({ guid: entity.guid })),
+  };
+  const writeRepository = {
+    target: OmniExternalRefEntity,
+    create: jest.fn((input: unknown) => input),
+    insert: jest.fn(async () => ({
+      identifiers: [{ guid: "eeeeeeee-1111-1111-1111-111111111111" }],
+    })),
+    update: jest.fn(async () => ({ affected: 1 })),
+  };
+
+  return { readRepository, writeRepository };
+};
+
+describe("OmniExternalRefService", () => {
+  it('requires a binding validator instead of silently bypassing target validation', () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+
+    expect(
+      () =>
+        new OmniExternalRefService(
+          readRepository as never,
+          writeRepository as never,
+          'hard',
+          undefined as never,
+        ),
+    ).toThrow('requires an OmniExternalRefBindingValidator');
+  });
+
+  it("looks up references by provider/external identity", async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    const service = new OmniExternalRefService(
+      readRepository as never,
+      writeRepository as never,
+      'hard',
+      bindingValidator as never,
+    );
+
+    await service.findByExternalIdentity({
+      provider: "github",
+      externalId: "123",
+      account: "acme",
+      container: "kb",
+    });
+
+    expect(readRepository.findOne).toHaveBeenCalledWith({
+      where: {
+        scopeId: "default",
+        provider: "github",
+        externalId: "123",
+        account: "acme",
+        container: "kb",
+      },
+    });
+  });
+
+  it("returns all references for an internal record", async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    const service = new OmniExternalRefService(
+      readRepository as never,
+      writeRepository as never,
+      'hard',
+      bindingValidator as never,
+    );
+
+    await service.findForInternalRecord(
+      OmniExternalRefInternalType.Document,
+      "doc-1",
+      "github",
+    );
+
+    expect(readRepository.find).toHaveBeenCalledWith({
+      where: {
+        scopeId: "default",
+        internalType: OmniExternalRefInternalType.Document,
+        internalId: "doc-1",
+        provider: "github",
+      },
+      order: {
+        createdAt: "ASC",
+      },
+    });
+  });
+
+  it("creates a new external ref when the identity does not exist", async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    readRepository.findOne.mockResolvedValue(null);
+    const service = new OmniExternalRefService(
+      readRepository as never,
+      writeRepository as never,
+      'hard',
+      bindingValidator as never,
+    );
+    const createSpy = jest
+      .spyOn(service, "createEntity")
+      .mockResolvedValue({ guid: "created" } as OmniExternalRefEntity);
+
+    const result = await service.upsertExternalRef({
+      internalType: OmniExternalRefInternalType.Document,
+      internalId: "doc-1",
+      provider: "github",
+      externalId: "123",
+    });
+
+    expect(createSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        internalType: OmniExternalRefInternalType.Document,
+        internalId: "doc-1",
+      }),
+    );
+    expect(result.guid).toBe("created");
+  });
+
+  it("validates record bindings without changing legacy non-record bindings", async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    readRepository.findOne.mockResolvedValue(null);
+    const validator = {
+      assertTarget: jest.fn(async () => ({})),
+    };
+    const service = new OmniExternalRefService(
+      readRepository as never,
+      writeRepository as never,
+      "hard",
+      validator as never,
+    );
+
+    await service.createEntity({
+      guid: "eeeeeeee-1111-1111-1111-111111111112",
+      provider: "example",
+      externalId: "record",
+      internalType: OmniExternalRefInternalType.Record,
+      internalId: "aaaaaaaa-1111-1111-1111-111111111111",
+    });
+    expect(validator.assertTarget).toHaveBeenCalledWith({
+      internalType: OmniExternalRefInternalType.Record,
+      internalId: "aaaaaaaa-1111-1111-1111-111111111111",
+    });
+
+    await service.createEntity({
+      guid: "eeeeeeee-1111-1111-1111-111111111113",
+      provider: "example",
+      externalId: "legacy-document",
+      internalType: OmniExternalRefInternalType.Document,
+      internalId: "aaaaaaaa-1111-1111-1111-111111111112",
+    });
+    expect(validator.assertTarget).toHaveBeenCalledTimes(1);
+  });
+
+  it("updates an existing external ref when the identity already exists", async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    readRepository.findOne.mockResolvedValue({
+      guid: "existing-guid",
+      internalType: OmniExternalRefInternalType.Document,
+      internalId: "doc-1",
+    });
+    const service = new OmniExternalRefService(
+      readRepository as never,
+      writeRepository as never,
+      'hard',
+      bindingValidator as never,
+    );
+    const updateSpy = jest
+      .spyOn(service, "updateEntity")
+      .mockResolvedValue({ guid: "existing-guid" } as OmniExternalRefEntity);
+
+    const result = await service.upsertExternalRef({
+      internalType: OmniExternalRefInternalType.Document,
+      internalId: "doc-1",
+      provider: "github",
+      externalId: "123",
+      payload: { synced: true },
+    });
+
+    expect(updateSpy).toHaveBeenCalledWith(
+      { guid: "existing-guid" },
+      expect.objectContaining({
+        payload: { synced: true },
+      }),
+    );
+    expect(result.guid).toBe("existing-guid");
+  });
+
+  it("rejects blank provider or external identity during upsert", async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    const service = new OmniExternalRefService(
+      readRepository as never,
+      writeRepository as never,
+      'hard',
+      bindingValidator as never,
+    );
+
+    await expect(
+      service.upsertExternalRef({
+        internalType: OmniExternalRefInternalType.Document,
+        internalId: "doc-1",
+        provider: "",
+        externalId: "123",
+      }),
+    ).rejects.toThrow("OmniExternalRef.provider is required");
+
+    await expect(
+      service.upsertExternalRef({
+        internalType: OmniExternalRefInternalType.Document,
+        internalId: "doc-1",
+        provider: "github",
+        externalId: "   ",
+      }),
+    ).rejects.toThrow("OmniExternalRef.externalId is required");
+  });
+
+  it("syncs document references with the document internal type", async () => {
+    const { readRepository, writeRepository } = createRepositoryPair();
+    const service = new OmniExternalRefService(
+      readRepository as never,
+      writeRepository as never,
+      'hard',
+      bindingValidator as never,
+    );
+    const upsertSpy = jest
+      .spyOn(service, "upsertExternalRef")
+      .mockResolvedValue({ guid: "doc-ref" } as OmniExternalRefEntity);
+
+    await service.syncDocumentReference("doc-1", {
+      provider: "github",
+      externalId: "123",
+      account: "acme",
+    });
+
+    expect(upsertSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        internalType: OmniExternalRefInternalType.Document,
+        internalId: "doc-1",
+      }),
+    );
+  });
+});

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

@@ -1,33 +1,33 @@
-import { describe, expect, it } from '@jest/globals';
-import { getMetadataArgsStorage } from 'typeorm';
-
-import { OmniBaseEntity } from '../base/omni-base.entity.js';
-import { OmniNamedEntity } from '../base/omni-named.entity.js';
-
-describe('OmniNamedEntity', () => {
-  it('extends OmniBaseEntity', () => {
-    expect(new OmniNamedEntity()).toBeInstanceOf(OmniBaseEntity);
-  });
-
-  it('registers the expected table and columns', () => {
-    const metadata = getMetadataArgsStorage();
-    const table = metadata.tables.find(
-      (item) => item.target === OmniNamedEntity,
-    );
-    const baseColumns = metadata.columns
-      .filter((item) => item.target === OmniBaseEntity)
-      .map((item) => item.propertyName);
-    const entityColumns = metadata.columns
-      .filter((item) => item.target === OmniNamedEntity)
-      .map((item) => item.propertyName);
-
-    expect(table?.name).toBe('omni-named');
-    expect(baseColumns).toEqual(expect.arrayContaining(['guid']));
-    expect(metadata.columns.map((item) => item.propertyName)).toEqual(
-      expect.arrayContaining(['createdAt', 'updatedAt']),
-    );
-    expect(entityColumns).toEqual(
-      expect.arrayContaining(['externalId', 'title', 'slug']),
-    );
-  });
-});
+import { describe, expect, it } from '@jest/globals';
+import { getMetadataArgsStorage } from 'typeorm';
+
+import { OmniBaseEntity } from '../base/omni-base.entity.js';
+import { OmniNamedEntity } from '../base/omni-named.entity.js';
+
+describe('OmniNamedEntity', () => {
+  it('extends OmniBaseEntity', () => {
+    expect(new OmniNamedEntity()).toBeInstanceOf(OmniBaseEntity);
+  });
+
+  it('registers the expected table and columns', () => {
+    const metadata = getMetadataArgsStorage();
+    const table = metadata.tables.find(
+      (item) => item.target === OmniNamedEntity,
+    );
+    const baseColumns = metadata.columns
+      .filter((item) => item.target === OmniBaseEntity)
+      .map((item) => item.propertyName);
+    const entityColumns = metadata.columns
+      .filter((item) => item.target === OmniNamedEntity)
+      .map((item) => item.propertyName);
+
+    expect(table?.name).toBe('omni-named');
+    expect(baseColumns).toEqual(expect.arrayContaining(['guid']));
+    expect(metadata.columns.map((item) => item.propertyName)).toEqual(
+      expect.arrayContaining(['createdAt', 'updatedAt']),
+    );
+    expect(entityColumns).toEqual(
+      expect.arrayContaining(['externalId', 'title', 'slug']),
+    );
+  });
+});