@nest-yalc-2/omnikernel-module 1.1.0

package/src/omni-relation.service.ts

@@ -0,0 +1,159 @@
+import { BadRequestException } from '@nestjs/common';
+import type { CrudGenFindManyOptions } from '@nest-yalc-2/crud-gen/api-graphql/crud-gen-gql.interface.js';
+import {
+  IsNull,
+  type DeepPartial,
+  type FindOptionsWhere,
+  type Repository,
+} from 'typeorm';
+import { OmniRecordEntity } from './base/omni-record.entity.js';
+import { OmniRelationEntity } from './base/omni-relation.entity.js';
+import {
+  canonicalOmniRelationKinds,
+  type OmniRelationKindContract,
+} from './omni-relation-kind.contract.js';
+import { isAllowedOmniRelation } from './omni-relation-semantics.js';
+import type { OmniDeletePolicy, OmniScope } from './omni-scope.js';
+import { OmniScopedService } from './omni-scoped.service.js';
+
+/**
+ * Scoped graph CRUD with immutable endpoints. The database composite foreign
+ * keys prevent cross-scope edges; this service additionally turns missing or
+ * invalid endpoints into normal API failures before persistence.
+ */
+export class OmniRelationService extends OmniScopedService<OmniRelationEntity> {
+  constructor(
+    repository: any,
+    scope: OmniScope,
+    deletion: OmniDeletePolicy,
+    protected readonly recordRepository: Repository<OmniRecordEntity>,
+    protected readonly kinds: OmniRelationKindContract,
+  ) {
+    super(repository, scope, deletion);
+  }
+
+  override async createEntity(
+    input: DeepPartial<OmniRelationEntity>,
+    findOptions?: CrudGenFindManyOptions<OmniRelationEntity>,
+    returnEntity?: true,
+  ): Promise<OmniRelationEntity>;
+  override async createEntity(
+    input: DeepPartial<OmniRelationEntity>,
+    findOptions?: CrudGenFindManyOptions<OmniRelationEntity>,
+    returnEntity?: boolean,
+  ): Promise<OmniRelationEntity | boolean>;
+  override async createEntity(
+    input: DeepPartial<OmniRelationEntity>,
+    findOptions?: CrudGenFindManyOptions<OmniRelationEntity>,
+    returnEntity = true,
+  ): Promise<OmniRelationEntity | boolean> {
+    this.rejectServerFields(input as object);
+    await this.assertRelation(input);
+    return super.createEntity(input, findOptions, returnEntity);
+  }
+
+  override async updateEntity(
+    conditions: FindOptionsWhere<OmniRelationEntity>,
+    input: DeepPartial<OmniRelationEntity>,
+    findOptions?: CrudGenFindManyOptions<OmniRelationEntity>,
+    returnEntity?: true,
+  ): Promise<OmniRelationEntity>;
+  override async updateEntity(
+    conditions: FindOptionsWhere<OmniRelationEntity>,
+    input: DeepPartial<OmniRelationEntity>,
+    findOptions?: CrudGenFindManyOptions<OmniRelationEntity>,
+    returnEntity?: boolean,
+  ): Promise<OmniRelationEntity | boolean>;
+  override async updateEntity(
+    conditions: FindOptionsWhere<OmniRelationEntity>,
+    input: DeepPartial<OmniRelationEntity>,
+    findOptions?: CrudGenFindManyOptions<OmniRelationEntity>,
+    returnEntity = true,
+  ): Promise<OmniRelationEntity | boolean> {
+    for (const field of ['guid', 'sourceRecordId', 'targetRecordId']) {
+      if (Object.prototype.hasOwnProperty.call(input, field)) {
+        throw new BadRequestException(`Omni relation ${field} is immutable.`);
+      }
+    }
+
+    const current = await super.getEntity(
+      conditions,
+      undefined,
+      undefined,
+      undefined,
+      {
+        failOnNull: true,
+      },
+    );
+    if (!current) this.notFound();
+    await this.assertRelation({ ...current, ...input });
+    return super.updateEntity(conditions, input, findOptions, returnEntity);
+  }
+
+  protected async assertRelation(
+    input: DeepPartial<OmniRelationEntity>,
+    recordRepository: Repository<OmniRecordEntity> = this.recordRepository,
+  ): Promise<void> {
+    const sourceRecordId = this.requiredIdentifier(
+      input.sourceRecordId,
+      'sourceRecordId',
+    );
+    const targetRecordId = this.requiredIdentifier(
+      input.targetRecordId,
+      'targetRecordId',
+    );
+    const kind = this.requiredIdentifier(input.kind, 'kind');
+    try {
+      this.kinds.assert(kind);
+    } catch (error) {
+      throw new BadRequestException(
+        error instanceof Error
+          ? error.message
+          : 'Omni relation kind is invalid.',
+      );
+    }
+
+    const records = await recordRepository.find({
+      where: [
+        { scopeId: this.scopeId, guid: sourceRecordId, deletedAt: IsNull() },
+        { scopeId: this.scopeId, guid: targetRecordId, deletedAt: IsNull() },
+      ],
+    });
+    const source = records.find((record) => record.guid === sourceRecordId);
+    const target = records.find((record) => record.guid === targetRecordId);
+    if (!source || !target) this.notFound();
+
+    this.assertEndpointKinds(source, target);
+
+    const isCanonical = canonicalOmniRelationKinds.includes(
+      kind as (typeof canonicalOmniRelationKinds)[number],
+    );
+    if (
+      isCanonical &&
+      !isAllowedOmniRelation({
+        sourceKind: source.kind,
+        targetKind: target.kind,
+        relationKind: kind,
+      })
+    ) {
+      throw new BadRequestException(
+        'Omni relation kind is not valid for these endpoint kinds.',
+      );
+    }
+  }
+
+  /** Resource-specific relation projections may narrow endpoint kinds. */
+  protected assertEndpointKinds(
+    _source: OmniRecordEntity,
+    _target: OmniRecordEntity,
+  ): void {}
+
+  protected requiredIdentifier(value: unknown, field: string): string {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+      throw new BadRequestException(
+        `Omni relation ${field} must be a non-empty string.`,
+      );
+    }
+    return value;
+  }
+}

package/src/omni-scope.d.ts

@@ -0,0 +1,33 @@
+export interface OmniScope {
+    readonly scopeId: string;
+    cacheKey(key: string): string;
+}
+export type OmniScopeResolver = (request: unknown) => string | undefined;
+export interface OmniKernelRegistrationOptions {
+    dbConnection: string;
+    resolveScope?: OmniScopeResolver;
+    defaultScopeId?: string;
+    reservedRecordKinds?: readonly string[];
+    relationKinds?: readonly string[];
+    deletion?: Partial<OmniDeletionPolicies>;
+}
+export type OmniDeletePolicy = 'hard' | 'tombstone';
+export interface OmniDeletionPolicies {
+    named: OmniDeletePolicy;
+    record: OmniDeletePolicy;
+    document: OmniDeletePolicy;
+    collection: OmniDeletePolicy;
+    relation: OmniDeletePolicy;
+    externalRef: OmniDeletePolicy;
+}
+export declare const OMNI_KERNEL_OPTIONS: unique symbol;
+export declare const defaultOmniDeletionPolicies: OmniDeletionPolicies;
+export declare function normalizeOmniKernelRegistrationOptions(options: string | OmniKernelRegistrationOptions): Required<Pick<OmniKernelRegistrationOptions, 'dbConnection' | 'defaultScopeId' | 'relationKinds'>> & Omit<OmniKernelRegistrationOptions, 'dbConnection' | 'defaultScopeId' | 'relationKinds' | 'reservedRecordKinds' | 'deletion'> & {
+    reservedRecordKinds: readonly string[];
+    deletion: OmniDeletionPolicies;
+};
+export declare class OmniScopeContext implements OmniScope {
+    readonly scopeId: string;
+    constructor(request: unknown, options: ReturnType<typeof normalizeOmniKernelRegistrationOptions>);
+    cacheKey(key: string): string;
+}

package/src/omni-scope.js

@@ -0,0 +1,91 @@
+"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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmniScopeContext = exports.defaultOmniDeletionPolicies = exports.OMNI_KERNEL_OPTIONS = void 0;
+exports.normalizeOmniKernelRegistrationOptions = normalizeOmniKernelRegistrationOptions;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+exports.OMNI_KERNEL_OPTIONS = Symbol('OMNI_KERNEL_OPTIONS');
+exports.defaultOmniDeletionPolicies = {
+    named: 'hard',
+    record: 'tombstone',
+    document: 'tombstone',
+    collection: 'tombstone',
+    relation: 'hard',
+    externalRef: 'hard',
+};
+function normalizeOmniDeletionPolicies(deletion) {
+    const knownResources = new Set(Object.keys(exports.defaultOmniDeletionPolicies));
+    for (const [resource, policy] of Object.entries(deletion ?? {})) {
+        if (!knownResources.has(resource)) {
+            throw new TypeError(`Unknown OmniKernel deletion policy resource: ${resource}.`);
+        }
+        if (policy !== 'hard' && policy !== 'tombstone') {
+            throw new TypeError(`OmniKernel deletion policy for ${resource} must be hard or tombstone.`);
+        }
+    }
+    return {
+        ...exports.defaultOmniDeletionPolicies,
+        ...deletion,
+    };
+}
+function normalizeOmniKernelRegistrationOptions(options) {
+    const candidate = typeof options === 'string' ? { dbConnection: options } : options;
+    if (!candidate.dbConnection) {
+        throw new TypeError('OmniKernelModule requires a database connection name.');
+    }
+    if (candidate.defaultScopeId !== undefined &&
+        (candidate.defaultScopeId.trim().length === 0 ||
+            candidate.defaultScopeId.length > 64)) {
+        throw new TypeError('OmniKernel defaultScopeId must be 1-64 characters.');
+    }
+    const reservedRecordKinds = candidate.reservedRecordKinds ?? [];
+    if (!Array.isArray(reservedRecordKinds) ||
+        reservedRecordKinds.some((kind) => typeof kind !== 'string' ||
+            kind.trim().length === 0 ||
+            kind.length > 64) ||
+        new Set(reservedRecordKinds).size !== reservedRecordKinds.length) {
+        throw new TypeError('OmniKernel reservedRecordKinds must be unique 1-64 character strings.');
+    }
+    return {
+        ...candidate,
+        defaultScopeId: candidate.defaultScopeId ?? 'default',
+        relationKinds: candidate.relationKinds ?? [],
+        reservedRecordKinds: Object.freeze([...reservedRecordKinds]),
+        deletion: normalizeOmniDeletionPolicies(candidate.deletion),
+    };
+}
+let OmniScopeContext = class OmniScopeContext {
+    constructor(request, options) {
+        const requestForResolver = request?.req ?? request;
+        const scopeId = options.resolveScope
+            ? options.resolveScope(requestForResolver)
+            : options.defaultScopeId;
+        if (!scopeId || scopeId.trim().length === 0 || scopeId.length > 64) {
+            throw new TypeError('Omni scope context is unavailable.');
+        }
+        this.scopeId = scopeId;
+    }
+    cacheKey(key) {
+        return `${this.scopeId}:${key}`;
+    }
+};
+exports.OmniScopeContext = OmniScopeContext;
+exports.OmniScopeContext = OmniScopeContext = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST }),
+    __param(0, (0, common_1.Inject)(core_1.REQUEST)),
+    __param(1, (0, common_1.Inject)(exports.OMNI_KERNEL_OPTIONS)),
+    __metadata("design:paramtypes", [Object, void 0])
+], OmniScopeContext);
+//# sourceMappingURL=omni-scope.js.map

package/src/omni-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omni-scope.js","sourceRoot":"","sources":["omni-scope.ts"],"names":[],"mappings":"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"}

package/src/omni-scope.ts

@@ -0,0 +1,161 @@
+import { Inject, Injectable, Scope } from '@nestjs/common';
+import { REQUEST } from '@nestjs/core';
+
+export interface OmniScope {
+  readonly scopeId: string;
+  cacheKey(key: string): string;
+}
+
+export type OmniScopeResolver = (request: unknown) => string | undefined;
+
+export interface OmniKernelRegistrationOptions {
+  dbConnection: string;
+  /**
+   * Authentication adapters resolve a trusted server scope from the request.
+   * The adapter owns authentication; OmniKernel never reads a client DTO field.
+   */
+  resolveScope?: OmniScopeResolver;
+  /**
+   * Compatibility/default partition for applications that do not yet have an
+   * authentication adapter. It is server configuration, never request input.
+   */
+  defaultScopeId?: string;
+  /** Kinds exclusively owned by registered extension projections. */
+  reservedRecordKinds?: readonly string[];
+  relationKinds?: readonly string[];
+  deletion?: Partial<OmniDeletionPolicies>;
+}
+
+export type OmniDeletePolicy = 'hard' | 'tombstone';
+
+export interface OmniDeletionPolicies {
+  named: OmniDeletePolicy;
+  record: OmniDeletePolicy;
+  document: OmniDeletePolicy;
+  collection: OmniDeletePolicy;
+  relation: OmniDeletePolicy;
+  externalRef: OmniDeletePolicy;
+}
+
+export const OMNI_KERNEL_OPTIONS = Symbol('OMNI_KERNEL_OPTIONS');
+
+export const defaultOmniDeletionPolicies: OmniDeletionPolicies = {
+  named: 'hard',
+  record: 'tombstone',
+  document: 'tombstone',
+  collection: 'tombstone',
+  relation: 'hard',
+  externalRef: 'hard',
+};
+
+function normalizeOmniDeletionPolicies(
+  deletion: Partial<OmniDeletionPolicies> | undefined,
+): OmniDeletionPolicies {
+  const knownResources = new Set(Object.keys(defaultOmniDeletionPolicies));
+  for (const [resource, policy] of Object.entries(deletion ?? {})) {
+    if (!knownResources.has(resource)) {
+      throw new TypeError(
+        `Unknown OmniKernel deletion policy resource: ${resource}.`,
+      );
+    }
+    if (policy !== 'hard' && policy !== 'tombstone') {
+      throw new TypeError(
+        `OmniKernel deletion policy for ${resource} must be hard or tombstone.`,
+      );
+    }
+  }
+  return {
+    ...defaultOmniDeletionPolicies,
+    ...deletion,
+  };
+}
+
+export function normalizeOmniKernelRegistrationOptions(
+  options: string | OmniKernelRegistrationOptions,
+): Required<
+  Pick<
+    OmniKernelRegistrationOptions,
+    'dbConnection' | 'defaultScopeId' | 'relationKinds'
+  >
+> &
+  Omit<
+    OmniKernelRegistrationOptions,
+    | 'dbConnection'
+    | 'defaultScopeId'
+    | 'relationKinds'
+    | 'reservedRecordKinds'
+    | 'deletion'
+  > & {
+    reservedRecordKinds: readonly string[];
+    deletion: OmniDeletionPolicies;
+  } {
+  const candidate =
+    typeof options === 'string' ? { dbConnection: options } : options;
+  if (!candidate.dbConnection) {
+    throw new TypeError(
+      'OmniKernelModule requires a database connection name.',
+    );
+  }
+  if (
+    candidate.defaultScopeId !== undefined &&
+    (candidate.defaultScopeId.trim().length === 0 ||
+      candidate.defaultScopeId.length > 64)
+  ) {
+    throw new TypeError('OmniKernel defaultScopeId must be 1-64 characters.');
+  }
+  const reservedRecordKinds = candidate.reservedRecordKinds ?? [];
+  if (
+    !Array.isArray(reservedRecordKinds) ||
+    reservedRecordKinds.some(
+      (kind) =>
+        typeof kind !== 'string' ||
+        kind.trim().length === 0 ||
+        kind.length > 64,
+    ) ||
+    new Set(reservedRecordKinds).size !== reservedRecordKinds.length
+  ) {
+    throw new TypeError(
+      'OmniKernel reservedRecordKinds must be unique 1-64 character strings.',
+    );
+  }
+
+  return {
+    ...candidate,
+    defaultScopeId: candidate.defaultScopeId ?? 'default',
+    relationKinds: candidate.relationKinds ?? [],
+    reservedRecordKinds: Object.freeze([...reservedRecordKinds]),
+    deletion: normalizeOmniDeletionPolicies(candidate.deletion),
+  };
+}
+
+type RequestEnvelope = { req?: unknown };
+
+/**
+ * Request-scoped server context used by every Omni generated API and loader.
+ * It is intentionally unavailable when neither the trusted adapter nor a
+ * configured default provides a scope.
+ */
+@Injectable({ scope: Scope.REQUEST })
+export class OmniScopeContext implements OmniScope {
+  readonly scopeId: string;
+
+  constructor(
+    @Inject(REQUEST) request: unknown,
+    @Inject(OMNI_KERNEL_OPTIONS)
+    options: ReturnType<typeof normalizeOmniKernelRegistrationOptions>,
+  ) {
+    const requestForResolver =
+      (request as RequestEnvelope | undefined)?.req ?? request;
+    const scopeId = options.resolveScope
+      ? options.resolveScope(requestForResolver)
+      : options.defaultScopeId;
+    if (!scopeId || scopeId.trim().length === 0 || scopeId.length > 64) {
+      throw new TypeError('Omni scope context is unavailable.');
+    }
+    this.scopeId = scopeId;
+  }
+
+  cacheKey(key: string): string {
+    return `${this.scopeId}:${key}`;
+  }
+}

package/src/omni-scoped.backend.d.ts

@@ -0,0 +1,21 @@
+import { type InjectionToken, type Provider } from '@nestjs/common';
+import { getProviderToken } from '@nest-yalc-2/crud-gen/crud-gen.helpers.js';
+import { type GenericService } from '@nest-yalc-2/crud-gen/typeorm/generic.service.js';
+import type { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import type { ObjectLiteral } from 'typeorm';
+import type { GenericTypeORMRepository } from '@nest-yalc-2/crud-gen/typeorm/generic.repository.js';
+import { OmniScopeContext, normalizeOmniKernelRegistrationOptions } from './omni-scope.js';
+export interface OmniScopedBackendFactoryOptions<Entity extends ObjectLiteral> {
+    entityModel: ClassType<Entity>;
+    dbConnection: string;
+    serviceToken?: string;
+    serviceProvider?: InjectionToken;
+    additionalInject?: readonly InjectionToken[];
+    createService: (repository: GenericTypeORMRepository<Entity>, scope: OmniScopeContext, options: ReturnType<typeof normalizeOmniKernelRegistrationOptions>, ...additionalDependencies: unknown[]) => GenericService<Entity>;
+}
+export interface OmniScopedBackendFactoryResult<Entity extends ObjectLiteral> {
+    providers: Provider[];
+    repository: ClassType<GenericTypeORMRepository<Entity>>;
+}
+export declare function omniScopedBackendProvidersFactory<Entity extends ObjectLiteral>(options: OmniScopedBackendFactoryOptions<Entity>): OmniScopedBackendFactoryResult<Entity>;
+export declare function omniBackendServiceToken(provider: Parameters<typeof getProviderToken>[0]): string;

package/src/omni-scoped.backend.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omniScopedBackendProvidersFactory = omniScopedBackendProvidersFactory;
+exports.omniBackendServiceToken = omniBackendServiceToken;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const crud_gen_helpers_js_1 = require("@nest-yalc-2/crud-gen/crud-gen.helpers.js");
+const generic_service_js_1 = require("@nest-yalc-2/crud-gen/typeorm/generic.service.js");
+const generic_repository_js_1 = require("@nest-yalc-2/crud-gen/typeorm/generic.repository.js");
+const data_loader_1 = require("@nest-yalc-2/data-loader");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const omni_scope_js_1 = require("./omni-scope.js");
+function omniScopedBackendProvidersFactory(options) {
+    const serviceToken = options.serviceToken ?? (0, generic_service_js_1.getServiceToken)(options.entityModel);
+    const serviceProviderToken = options.serviceProvider ?? serviceToken;
+    const additionalInject = options.additionalInject ?? [];
+    const serviceProvider = {
+        provide: serviceProviderToken,
+        scope: common_1.Scope.REQUEST,
+        useFactory: (repository, scope, moduleOptions, ...additionalDependencies) => options.createService(repository, scope, moduleOptions, ...additionalDependencies),
+        inject: [
+            (0, typeorm_1.getRepositoryToken)(options.entityModel, options.dbConnection),
+            omni_scope_js_1.OmniScopeContext,
+            omni_scope_js_1.OMNI_KERNEL_OPTIONS,
+            ...additionalInject,
+        ],
+    };
+    const loaderProvider = {
+        provide: (0, data_loader_1.getDataloaderToken)(options.entityModel),
+        scope: common_1.Scope.REQUEST,
+        useFactory: (service, scope, events) => new data_loader_1.GQLDataLoader((0, data_loader_1.getFn)(service), 'guid', events, {
+            cacheKeyFn: (key) => scope.cacheKey(key),
+        }),
+        inject: [serviceToken, omni_scope_js_1.OmniScopeContext, event_emitter_1.EventEmitter2],
+    };
+    const serviceAlias = serviceProviderToken === serviceToken
+        ? []
+        : [{ provide: serviceToken, useExisting: serviceProviderToken }];
+    return {
+        providers: [serviceProvider, ...serviceAlias, loaderProvider],
+        repository: (0, generic_repository_js_1.CGExtendedRepositoryFactory)(options.entityModel),
+    };
+}
+function omniBackendServiceToken(provider) {
+    return (0, crud_gen_helpers_js_1.getProviderToken)(provider);
+}
+//# sourceMappingURL=omni-scoped.backend.js.map

package/src/omni-scoped.backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omni-scoped.backend.js","sourceRoot":"","sources":["omni-scoped.backend.ts"],"names":[],"mappings":";;AAmDA,8EAoDC;AAED,0DAIC;AA7GD,2CAKwB;AACxB,6CAAqD;AACrD,mFAA6E;AAC7E,yFAG0D;AAC1D,+FAAkG;AAClG,0DAIkC;AAElC,yDAAsD;AAGtD,mDAIyB;AAyBzB,SAAgB,iCAAiC,CAC/C,OAAgD;IAEhD,MAAM,YAAY,GAChB,OAAO,CAAC,YAAY,IAAI,IAAA,oCAAe,EAAC,OAAO,CAAC,WAAW,CAAC,CAAC;IAC/D,MAAM,oBAAoB,GAAG,OAAO,CAAC,eAAe,IAAI,YAAY,CAAC;IACrE,MAAM,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,IAAI,EAAE,CAAC;IACxD,MAAM,eAAe,GAAoB;QACvC,OAAO,EAAE,oBAAoB;QAC7B,KAAK,EAAE,cAAK,CAAC,OAAO;QACpB,UAAU,EAAE,CACV,UAA4C,EAC5C,KAAuB,EACvB,aAAwE,EACxE,GAAG,sBAAiC,EACpC,EAAE,CACF,OAAO,CAAC,aAAa,CACnB,UAAU,EACV,KAAK,EACL,aAAa,EACb,GAAG,sBAAsB,CAC1B;QACH,MAAM,EAAE;YACN,IAAA,4BAAkB,EAAC,OAAO,CAAC,WAAW,EAAE,OAAO,CAAC,YAAY,CAAC;YAC7D,gCAAgB;YAChB,mCAAmB;YACnB,GAAG,gBAAgB;SACpB;KACF,CAAC;IACF,MAAM,cAAc,GAAoB;QACtC,OAAO,EAAE,IAAA,gCAAkB,EAAC,OAAO,CAAC,WAAW,CAAC;QAChD,KAAK,EAAE,cAAK,CAAC,OAAO;QACpB,UAAU,EAAE,CACV,OAA+B,EAC/B,KAAuB,EACvB,MAAqB,EACrB,EAAE,CACF,IAAI,2BAAa,CAAC,IAAA,mBAAK,EAAC,OAAO,CAAC,EAAE,MAAsB,EAAE,MAAM,EAAE;YAChE,UAAU,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;SACzC,CAAC;QACJ,MAAM,EAAE,CAAC,YAAY,EAAE,gCAAgB,EAAE,6BAAa,CAAC;KACxD,CAAC;IAEF,MAAM,YAAY,GAChB,oBAAoB,KAAK,YAAY;QACnC,CAAC,CAAC,EAAE;QACJ,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC,CAAC;IAErE,OAAO;QACL,SAAS,EAAE,CAAC,eAAe,EAAE,GAAG,YAAY,EAAE,cAAc,CAAC;QAC7D,UAAU,EAAE,IAAA,mDAA2B,EAAC,OAAO,CAAC,WAAW,CAAC;KAC7D,CAAC;AACJ,CAAC;AAED,SAAgB,uBAAuB,CACrC,QAAgD;IAEhD,OAAO,IAAA,sCAAgB,EAAC,QAAQ,CAAC,CAAC;AACpC,CAAC"}

package/src/omni-scoped.backend.ts

@@ -0,0 +1,110 @@
+import {
+  Scope,
+  type FactoryProvider,
+  type InjectionToken,
+  type Provider,
+} from '@nestjs/common';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { getProviderToken } from '@nest-yalc-2/crud-gen/crud-gen.helpers.js';
+import {
+  getServiceToken,
+  type GenericService,
+} from '@nest-yalc-2/crud-gen/typeorm/generic.service.js';
+import { CGExtendedRepositoryFactory } from '@nest-yalc-2/crud-gen/typeorm/generic.repository.js';
+import {
+  GQLDataLoader,
+  getDataloaderToken,
+  getFn,
+} from '@nest-yalc-2/data-loader';
+import type { ClassType } from '@nest-yalc-2/types/globals.d.js';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import type { ObjectLiteral } from 'typeorm';
+import type { GenericTypeORMRepository } from '@nest-yalc-2/crud-gen/typeorm/generic.repository.js';
+import {
+  OMNI_KERNEL_OPTIONS,
+  OmniScopeContext,
+  normalizeOmniKernelRegistrationOptions,
+} from './omni-scope.js';
+
+export interface OmniScopedBackendFactoryOptions<Entity extends ObjectLiteral> {
+  entityModel: ClassType<Entity>;
+  dbConnection: string;
+  serviceToken?: string;
+  serviceProvider?: InjectionToken;
+  additionalInject?: readonly InjectionToken[];
+  createService: (
+    repository: GenericTypeORMRepository<Entity>,
+    scope: OmniScopeContext,
+    options: ReturnType<typeof normalizeOmniKernelRegistrationOptions>,
+    ...additionalDependencies: unknown[]
+  ) => GenericService<Entity>;
+}
+
+export interface OmniScopedBackendFactoryResult<Entity extends ObjectLiteral> {
+  providers: Provider[];
+  repository: ClassType<GenericTypeORMRepository<Entity>>;
+}
+
+/**
+ * Builds the normal CrudGen service/loader provider shape with a request
+ * scope. The loader cache key carries the same scope as the service query.
+ */
+export function omniScopedBackendProvidersFactory<Entity extends ObjectLiteral>(
+  options: OmniScopedBackendFactoryOptions<Entity>,
+): OmniScopedBackendFactoryResult<Entity> {
+  const serviceToken =
+    options.serviceToken ?? getServiceToken(options.entityModel);
+  const serviceProviderToken = options.serviceProvider ?? serviceToken;
+  const additionalInject = options.additionalInject ?? [];
+  const serviceProvider: FactoryProvider = {
+    provide: serviceProviderToken,
+    scope: Scope.REQUEST,
+    useFactory: (
+      repository: GenericTypeORMRepository<Entity>,
+      scope: OmniScopeContext,
+      moduleOptions: ReturnType<typeof normalizeOmniKernelRegistrationOptions>,
+      ...additionalDependencies: unknown[]
+    ) =>
+      options.createService(
+        repository,
+        scope,
+        moduleOptions,
+        ...additionalDependencies,
+      ),
+    inject: [
+      getRepositoryToken(options.entityModel, options.dbConnection),
+      OmniScopeContext,
+      OMNI_KERNEL_OPTIONS,
+      ...additionalInject,
+    ],
+  };
+  const loaderProvider: FactoryProvider = {
+    provide: getDataloaderToken(options.entityModel),
+    scope: Scope.REQUEST,
+    useFactory: (
+      service: GenericService<Entity>,
+      scope: OmniScopeContext,
+      events: EventEmitter2,
+    ) =>
+      new GQLDataLoader(getFn(service), 'guid' as keyof Entity, events, {
+        cacheKeyFn: (key) => scope.cacheKey(key),
+      }),
+    inject: [serviceToken, OmniScopeContext, EventEmitter2],
+  };
+
+  const serviceAlias: Provider[] =
+    serviceProviderToken === serviceToken
+      ? []
+      : [{ provide: serviceToken, useExisting: serviceProviderToken }];
+
+  return {
+    providers: [serviceProvider, ...serviceAlias, loaderProvider],
+    repository: CGExtendedRepositoryFactory(options.entityModel),
+  };
+}
+
+export function omniBackendServiceToken(
+  provider: Parameters<typeof getProviderToken>[0],
+): string {
+  return getProviderToken(provider);
+}

package/src/omni-scoped.repository.d.ts

@@ -0,0 +1,10 @@
+import type { FindOptionsWhere, ObjectLiteral, Repository } from 'typeorm';
+import type { OmniScope } from './omni-scope.js';
+export declare class OmniScopedRepository<Entity extends ObjectLiteral> {
+    private readonly repository;
+    private readonly scope;
+    constructor(repository: Repository<Entity>, scope: OmniScope);
+    where(where?: FindOptionsWhere<Entity>): FindOptionsWhere<Entity>;
+    findOneByGuid(guid: string): Promise<Entity | null>;
+    find(where?: FindOptionsWhere<Entity>): Promise<Entity[]>;
+}

package/src/omni-scoped.repository.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmniScopedRepository = void 0;
+class OmniScopedRepository {
+    constructor(repository, scope) {
+        this.repository = repository;
+        this.scope = scope;
+    }
+    where(where = {}) {
+        if ('scopeId' in where) {
+            throw new TypeError('Omni scopeId is derived from server context.');
+        }
+        return {
+            ...where,
+            scopeId: this.scope.scopeId,
+        };
+    }
+    findOneByGuid(guid) {
+        return this.repository.findOne({ where: this.where({ guid }) });
+    }
+    find(where = {}) {
+        return this.repository.find({ where: this.where(where) });
+    }
+}
+exports.OmniScopedRepository = OmniScopedRepository;
+//# sourceMappingURL=omni-scoped.repository.js.map