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

package/src/__tests__/omni-scope-substrate.spec.ts

@@ -1,81 +1,81 @@
-import { describe, expect, it, jest } from "@jest/globals";
-
-import { canonicalOmniRelationKinds, createOmniRelationKindContract } from '../omni-relation-kind.contract.js';
-import { normalizeOmniKernelRegistrationOptions, OmniScopeContext } from '../omni-scope.js';
-import { OmniScopedRepository } from '../omni-scoped.repository.js';
-
-describe("Omni scoped substrate", () => {
-  it("derives a trusted scope, scopes cache keys, and rejects invalid registration", () => {
-    const options = normalizeOmniKernelRegistrationOptions({
-      dbConnection: "default",
-      defaultScopeId: "fallback",
-      resolveScope: (request) =>
-        (request as { authenticatedScope?: string }).authenticatedScope,
-      relationKinds: ["blocks"],
-      deletion: { record: "tombstone" },
-    });
-    const scope = new OmniScopeContext(
-      { req: { authenticatedScope: "scope-alpha" } },
-      options,
-    );
-
-    expect(scope.scopeId).toBe("scope-alpha");
-    expect(scope.cacheKey("record-1")).toBe("scope-alpha:record-1");
-    expect(options.deletion.document).toBe("tombstone");
-    expect(() => new OmniScopeContext({ req: {} }, options)).toThrow(
-      "unavailable",
-    );
-    expect(() =>
-      normalizeOmniKernelRegistrationOptions({
-        dbConnection: "",
-      }),
-    ).toThrow("database connection");
-    expect(() =>
-      normalizeOmniKernelRegistrationOptions({
-        dbConnection: "default",
-        deletion: { record: "erase" as never },
-      }),
-    ).toThrow("must be hard or tombstone");
-    expect(() =>
-      normalizeOmniKernelRegistrationOptions({
-        dbConnection: "default",
-        deletion: { records: "tombstone" } as never,
-      }),
-    ).toThrow("Unknown OmniKernel deletion policy resource");
-  });
-
-  it("keeps canonical relation kinds stable while validating registered extensions", () => {
-    const contract = createOmniRelationKindContract(["blocks"]);
-
-    expect(canonicalOmniRelationKinds).toContain("contains");
-    expect(contract.has("blocks")).toBe(true);
-    expect(() => contract.assert("unknown")).toThrow("not registered");
-    expect(() => createOmniRelationKindContract(["not portable!"])).toThrow(
-      "lowercase letters",
-    );
-  });
-
-  it("adds scope to lower-level repository queries and refuses caller scope input", async () => {
-    const repository = {
-      find: jest.fn(async () => []),
-      findOne: jest.fn(async () => null),
-    };
-    const scoped = new OmniScopedRepository(repository as never, {
-      scopeId: "scope-alpha",
-      cacheKey: (key: string) => key,
-    });
-
-    await scoped.findOneByGuid("record-1");
-    await scoped.find({ title: "Scoped record" } as never);
-
-    expect(repository.findOne).toHaveBeenCalledWith({
-      where: { guid: "record-1", scopeId: "scope-alpha" },
-    });
-    expect(repository.find).toHaveBeenCalledWith({
-      where: { title: "Scoped record", scopeId: "scope-alpha" },
-    });
-    expect(() => scoped.where({ scopeId: "scope-bravo" } as never)).toThrow(
-      "derived from server context",
-    );
-  });
-});
+import { describe, expect, it, jest } from "@jest/globals";
+
+import { canonicalOmniRelationKinds, createOmniRelationKindContract } from '../omni-relation-kind.contract.js';
+import { normalizeOmniKernelRegistrationOptions, OmniScopeContext } from '../omni-scope.js';
+import { OmniScopedRepository } from '../omni-scoped.repository.js';
+
+describe("Omni scoped substrate", () => {
+  it("derives a trusted scope, scopes cache keys, and rejects invalid registration", () => {
+    const options = normalizeOmniKernelRegistrationOptions({
+      dbConnection: "default",
+      defaultScopeId: "fallback",
+      resolveScope: (request) =>
+        (request as { authenticatedScope?: string }).authenticatedScope,
+      relationKinds: ["blocks"],
+      deletion: { record: "tombstone" },
+    });
+    const scope = new OmniScopeContext(
+      { req: { authenticatedScope: "scope-alpha" } },
+      options,
+    );
+
+    expect(scope.scopeId).toBe("scope-alpha");
+    expect(scope.cacheKey("record-1")).toBe("scope-alpha:record-1");
+    expect(options.deletion.document).toBe("tombstone");
+    expect(() => new OmniScopeContext({ req: {} }, options)).toThrow(
+      "unavailable",
+    );
+    expect(() =>
+      normalizeOmniKernelRegistrationOptions({
+        dbConnection: "",
+      }),
+    ).toThrow("database connection");
+    expect(() =>
+      normalizeOmniKernelRegistrationOptions({
+        dbConnection: "default",
+        deletion: { record: "erase" as never },
+      }),
+    ).toThrow("must be hard or tombstone");
+    expect(() =>
+      normalizeOmniKernelRegistrationOptions({
+        dbConnection: "default",
+        deletion: { records: "tombstone" } as never,
+      }),
+    ).toThrow("Unknown OmniKernel deletion policy resource");
+  });
+
+  it("keeps canonical relation kinds stable while validating registered extensions", () => {
+    const contract = createOmniRelationKindContract(["blocks"]);
+
+    expect(canonicalOmniRelationKinds).toContain("contains");
+    expect(contract.has("blocks")).toBe(true);
+    expect(() => contract.assert("unknown")).toThrow("not registered");
+    expect(() => createOmniRelationKindContract(["not portable!"])).toThrow(
+      "lowercase letters",
+    );
+  });
+
+  it("adds scope to lower-level repository queries and refuses caller scope input", async () => {
+    const repository = {
+      find: jest.fn(async () => []),
+      findOne: jest.fn(async () => null),
+    };
+    const scoped = new OmniScopedRepository(repository as never, {
+      scopeId: "scope-alpha",
+      cacheKey: (key: string) => key,
+    });
+
+    await scoped.findOneByGuid("record-1");
+    await scoped.find({ title: "Scoped record" } as never);
+
+    expect(repository.findOne).toHaveBeenCalledWith({
+      where: { guid: "record-1", scopeId: "scope-alpha" },
+    });
+    expect(repository.find).toHaveBeenCalledWith({
+      where: { title: "Scoped record", scopeId: "scope-alpha" },
+    });
+    expect(() => scoped.where({ scopeId: "scope-bravo" } as never)).toThrow(
+      "derived from server context",
+    );
+  });
+});

package/src/__tests__/omni-scoped.backend.spec.ts

@@ -1,115 +1,115 @@
-import { describe, expect, it } from "@jest/globals";
-import { EventEmitter2 } from "@nestjs/event-emitter";
-
-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 { OmniDocumentEntity } from '../omni-document.entity.js';
-import { OmniExternalRefEntity } from '../base/omni-external-ref.entity.js';
-import { OmniExternalRefService } from '../omni-external-ref.service.js';
-import { OmniRelationService } from '../omni-relation.service.js';
-import { OmniScopedService } from '../omni-scoped.service.js';
-import { normalizeOmniKernelRegistrationOptions } from '../omni-scope.js';
-import { omniScopedBackendProvidersFactory, omniBackendServiceToken } from '../omni-scoped.backend.js';
-import { omniNamedBackendProvidersFactory } from '../omni-named.backend.js';
-import { omniRecordBackendProvidersFactory } from '../omni-record.backend.js';
-import { omniRelationBackendProvidersFactory } from '../omni-relation.backend.js';
-import { omniCollectionBackendProvidersFactory } from '../omni-collection.backend.js';
-import { omniDocumentBackendProvidersFactory } from '../omni-document.backend.js';
-import { omniExternalRefBackendProvidersFactory } from '../omni-external-ref.backend.js';
-
-const scope = {
-  scopeId: "scope-alpha",
-  cacheKey: (key: string) => `scope-alpha:${key}`,
-};
-const options = normalizeOmniKernelRegistrationOptions({
-  dbConnection: "default",
-  relationKinds: ["blocks"],
-});
-
-const repositoryFor = (target: unknown) => ({ target });
-
-const factoryProvider = (providers: unknown[]) =>
-  providers.find(
-    (provider) =>
-      typeof provider === "object" &&
-      provider !== null &&
-      "useFactory" in provider,
-  ) as { useFactory: (...dependencies: unknown[]) => unknown };
-
-describe("Omni scoped backend providers", () => {
-  it("builds request-scoped generic services for every ordinary resource", () => {
-    const cases = [
-      [omniNamedBackendProvidersFactory, OmniNamedEntity],
-      [omniRecordBackendProvidersFactory, OmniRecordEntity],
-      [omniCollectionBackendProvidersFactory, OmniCollectionEntity],
-      [omniDocumentBackendProvidersFactory, OmniDocumentEntity],
-    ] as const;
-
-    for (const [factory, entity] of cases) {
-      const backend = factory("default");
-      const service = factoryProvider(backend.providers).useFactory(
-        repositoryFor(entity),
-        scope,
-        options,
-      );
-      expect(service).toBeInstanceOf(OmniScopedService);
-    }
-  });
-
-  it("builds the relation service with a scoped record dependency", () => {
-    const backend = omniRelationBackendProvidersFactory("default");
-    const service = factoryProvider(backend.providers).useFactory(
-      repositoryFor(OmniRelationEntity),
-      scope,
-      options,
-      repositoryFor(OmniRecordEntity),
-    );
-
-    expect(service).toBeInstanceOf(OmniRelationService);
-  });
-
-  it("builds the external-reference service and exposes its service alias", () => {
-    const backend = omniExternalRefBackendProvidersFactory("default");
-    const service = factoryProvider(backend.providers).useFactory(
-      repositoryFor(OmniExternalRefEntity),
-      scope,
-      options,
-    );
-
-    expect(service).toBeInstanceOf(OmniExternalRefService);
-    expect(backend.providers).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({ provide: OmniExternalRefService }),
-      ]),
-    );
-    expect(omniBackendServiceToken(OmniExternalRefService)).toBe(
-      "OmniExternalRefService",
-    );
-  });
-
-  it("uses the scope-prefixed cache key in the generated request loader", () => {
-    const backend = omniScopedBackendProvidersFactory({
-      entityModel: OmniRecordEntity,
-      dbConnection: "default",
-      createService: (repository, resolvedScope) =>
-        new OmniScopedService(repository, resolvedScope),
-    });
-    const loaderProvider = backend.providers.find(
-      (provider) =>
-        typeof provider === "object" &&
-        provider !== null &&
-        "useFactory" in provider &&
-        provider !== factoryProvider(backend.providers),
-    ) as { useFactory: (...dependencies: unknown[]) => unknown };
-    const service = new OmniScopedService(
-      repositoryFor(OmniRecordEntity) as never,
-      scope,
-    );
-
-    expect(
-      loaderProvider.useFactory(service, scope, new EventEmitter2()),
-    ).toBeDefined();
-  });
-});
+import { describe, expect, it } from "@jest/globals";
+import { EventEmitter2 } from "@nestjs/event-emitter";
+
+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 { OmniDocumentEntity } from '../omni-document.entity.js';
+import { OmniExternalRefEntity } from '../base/omni-external-ref.entity.js';
+import { OmniExternalRefService } from '../omni-external-ref.service.js';
+import { OmniRelationService } from '../omni-relation.service.js';
+import { OmniScopedService } from '../omni-scoped.service.js';
+import { normalizeOmniKernelRegistrationOptions } from '../omni-scope.js';
+import { omniScopedBackendProvidersFactory, omniBackendServiceToken } from '../omni-scoped.backend.js';
+import { omniNamedBackendProvidersFactory } from '../omni-named.backend.js';
+import { omniRecordBackendProvidersFactory } from '../omni-record.backend.js';
+import { omniRelationBackendProvidersFactory } from '../omni-relation.backend.js';
+import { omniCollectionBackendProvidersFactory } from '../omni-collection.backend.js';
+import { omniDocumentBackendProvidersFactory } from '../omni-document.backend.js';
+import { omniExternalRefBackendProvidersFactory } from '../omni-external-ref.backend.js';
+
+const scope = {
+  scopeId: "scope-alpha",
+  cacheKey: (key: string) => `scope-alpha:${key}`,
+};
+const options = normalizeOmniKernelRegistrationOptions({
+  dbConnection: "default",
+  relationKinds: ["blocks"],
+});
+
+const repositoryFor = (target: unknown) => ({ target });
+
+const factoryProvider = (providers: unknown[]) =>
+  providers.find(
+    (provider) =>
+      typeof provider === "object" &&
+      provider !== null &&
+      "useFactory" in provider,
+  ) as { useFactory: (...dependencies: unknown[]) => unknown };
+
+describe("Omni scoped backend providers", () => {
+  it("builds request-scoped generic services for every ordinary resource", () => {
+    const cases = [
+      [omniNamedBackendProvidersFactory, OmniNamedEntity],
+      [omniRecordBackendProvidersFactory, OmniRecordEntity],
+      [omniCollectionBackendProvidersFactory, OmniCollectionEntity],
+      [omniDocumentBackendProvidersFactory, OmniDocumentEntity],
+    ] as const;
+
+    for (const [factory, entity] of cases) {
+      const backend = factory("default");
+      const service = factoryProvider(backend.providers).useFactory(
+        repositoryFor(entity),
+        scope,
+        options,
+      );
+      expect(service).toBeInstanceOf(OmniScopedService);
+    }
+  });
+
+  it("builds the relation service with a scoped record dependency", () => {
+    const backend = omniRelationBackendProvidersFactory("default");
+    const service = factoryProvider(backend.providers).useFactory(
+      repositoryFor(OmniRelationEntity),
+      scope,
+      options,
+      repositoryFor(OmniRecordEntity),
+    );
+
+    expect(service).toBeInstanceOf(OmniRelationService);
+  });
+
+  it("builds the external-reference service and exposes its service alias", () => {
+    const backend = omniExternalRefBackendProvidersFactory("default");
+    const service = factoryProvider(backend.providers).useFactory(
+      repositoryFor(OmniExternalRefEntity),
+      scope,
+      options,
+    );
+
+    expect(service).toBeInstanceOf(OmniExternalRefService);
+    expect(backend.providers).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ provide: OmniExternalRefService }),
+      ]),
+    );
+    expect(omniBackendServiceToken(OmniExternalRefService)).toBe(
+      "OmniExternalRefService",
+    );
+  });
+
+  it("uses the scope-prefixed cache key in the generated request loader", () => {
+    const backend = omniScopedBackendProvidersFactory({
+      entityModel: OmniRecordEntity,
+      dbConnection: "default",
+      createService: (repository, resolvedScope) =>
+        new OmniScopedService(repository, resolvedScope),
+    });
+    const loaderProvider = backend.providers.find(
+      (provider) =>
+        typeof provider === "object" &&
+        provider !== null &&
+        "useFactory" in provider &&
+        provider !== factoryProvider(backend.providers),
+    ) as { useFactory: (...dependencies: unknown[]) => unknown };
+    const service = new OmniScopedService(
+      repositoryFor(OmniRecordEntity) as never,
+      scope,
+    );
+
+    expect(
+      loaderProvider.useFactory(service, scope, new EventEmitter2()),
+    ).toBeDefined();
+  });
+});