@nest-yalc-2/omnikernel-module 1.1.0

package/src/omni-extension-projection.service.ts

@@ -0,0 +1,452 @@
+import type { CrudGenFindManyOptions } from '@nest-yalc-2/crud-gen';
+import {
+  PROJECTION_INTEGER_MAX,
+  ProjectionResourceService,
+  type ProjectionDialect,
+  type ProjectionValuePatch,
+} from '@nest-yalc-2/crud-gen';
+import { YalcEventService } from '@nest-yalc-2/event-manager';
+import {
+  In,
+  IsNull,
+  type DataSource,
+  type EntityManager,
+  type ObjectLiteral,
+  type Repository,
+} from 'typeorm';
+import { OmniRecordEntity } from './base/omni-record.entity.js';
+import {
+  createOmniProjectionReaderCatalog,
+  type OmniProjectionReaderCatalog,
+} from './omni-projection.catalog.js';
+import type { OmniExtensionProjectionDefinition } from './omni-extension-projection.definition.js';
+import type { OmniProjectionLifecycle } from './omni-projection.lifecycle.js';
+import type { OmniScope } from './omni-scope.js';
+
+function hasOwn(input: Record<string, unknown>, field: string): boolean {
+  return Object.prototype.hasOwnProperty.call(input, field);
+}
+
+function isUniqueConstraint(error: unknown): boolean {
+  const candidate = error as { driverError?: { code?: unknown } } | undefined;
+  const code = candidate?.driverError?.code;
+  return code === 'SQLITE_CONSTRAINT' || code === '23505';
+}
+
+function isRetryableTransactionError(error: unknown): boolean {
+  const candidate = error as {
+    code?: unknown;
+    driverError?: { code?: unknown };
+  };
+  const code = candidate?.driverError?.code ?? candidate?.code;
+  return (
+    code === '40001' ||
+    code === 'SQLITE_BUSY' ||
+    code === 'SQLITE_BUSY_SNAPSHOT'
+  );
+}
+
+/**
+ * Generated-CRUD compatible store for a dedicated extension table. It keeps
+ * the Omni record as the only root identity and revision owner, while the
+ * extension table owns projected columns and its native JSON payload.
+ */
+export class OmniExtensionProjectionService<
+  Extension extends ObjectLiteral,
+> extends ProjectionResourceService<Extension> {
+  constructor(
+    extensionRepository: Repository<Extension>,
+    private readonly ownerRepository: Repository<OmniRecordEntity>,
+    private readonly dataSource: DataSource,
+    scope: OmniScope,
+    dialect: ProjectionDialect,
+    events: YalcEventService,
+    private readonly omniDefinition: OmniExtensionProjectionDefinition,
+    private readonly lifecycle?: OmniProjectionLifecycle<
+      OmniExtensionProjectionDefinition,
+      Extension
+    >,
+    private readonly readerCatalog?: OmniProjectionReaderCatalog,
+  ) {
+    super(extensionRepository, scope, dialect, events, omniDefinition);
+  }
+
+  override async getEntity(
+    conditions: Record<string, unknown>,
+    _fields?: string[],
+    _relations?: string[],
+    _databaseName?: string,
+    options?: { failOnNull?: boolean },
+  ): Promise<Extension | null> {
+    const guid = this.guidFromConditions(conditions);
+    const entity = await this.readOne(guid);
+    if (!entity && options?.failOnNull) this.notFound();
+    return entity;
+  }
+
+  override async getEntityListExtended(
+    findOptions: CrudGenFindManyOptions<Extension> = {},
+    withCount = false,
+  ): Promise<Extension[] | [Extension[], number]> {
+    const [extensions, count] = await this.dialect.findMany(
+      this.repository,
+      this.definition,
+      this.scope.scopeId,
+      this.filtersFromFindOptions(findOptions),
+      this.sortingFromFindOptions(findOptions),
+      this.pageFromFindOptions(findOptions),
+    );
+    const guidColumn = this.definition.identity.column;
+    const guids = extensions.map(
+      (extension) =>
+        (extension as Record<string, unknown>)[guidColumn] as string,
+    );
+    if (guids.length === 0) return withCount ? [[], count] : [];
+
+    const owners = await this.ownerRepository.find({
+      where: {
+        scopeId: this.scope.scopeId,
+        guid: In(guids),
+        kind: this.omniDefinition.owner.kind,
+        payloadSchemaId: this.omniDefinition.owner.schema.id,
+        payloadSchemaVersion: this.omniDefinition.owner.schema.version,
+        deletedAt: IsNull(),
+      },
+    });
+    const ownersByGuid = new Map(owners.map((owner) => [owner.guid, owner]));
+    if (ownersByGuid.size !== extensions.length) {
+      throw new Error(
+        'Omni extension projection invariant failed: an extension owner is unavailable.',
+      );
+    }
+    const projected = extensions.map((extension) =>
+      this.merge(extension, ownersByGuid.get((extension as any)[guidColumn])!),
+    );
+    return withCount ? [projected, count] : projected;
+  }
+
+  override async createEntity(
+    input: Record<string, unknown>,
+  ): Promise<Extension> {
+    this.rejectUnknownInput(input, true);
+    const extension = this.createExtension(input);
+    const guid = extension[this.definition.identity.column] as string;
+    const owner = this.ownerRepository.create({
+      scopeId: this.scope.scopeId,
+      guid,
+      title: this.omniDefinition.owner.title,
+      kind: this.omniDefinition.owner.kind,
+      status: this.omniDefinition.owner.status,
+      payload: null,
+      payloadSchemaId: this.omniDefinition.owner.schema.id,
+      payloadSchemaVersion: this.omniDefinition.owner.schema.version,
+    });
+
+    try {
+      return await this.mutate(async (manager) => {
+        await this.lifecycle?.beforeCreate?.({
+          definition: this.omniDefinition,
+          scope: this.scope,
+          manager,
+          readers: this.readers(manager),
+          input,
+        });
+        await manager.getRepository(OmniRecordEntity).save(owner);
+        const saved = await manager
+          .getRepository(this.repository.target)
+          .save(extension as Extension);
+        return this.merge(saved, owner);
+      });
+    } catch (error) {
+      if (isUniqueConstraint(error)) this.identityConflict();
+      throw error;
+    }
+  }
+
+  override async updateEntity(
+    conditions: Record<string, unknown>,
+    input: Record<string, unknown>,
+  ): Promise<Extension> {
+    this.rejectUnknownInput(input, false);
+    const guid = this.guidFromConditions(conditions);
+    const expectedRevision = input.expectedRevision;
+    if (
+      typeof expectedRevision !== 'number' ||
+      !Number.isInteger(expectedRevision) ||
+      expectedRevision < 1 ||
+      expectedRevision >= PROJECTION_INTEGER_MAX
+    ) {
+      this.invalid(
+        `expectedRevision must be an integer between 1 and ${PROJECTION_INTEGER_MAX - 1}.`,
+      );
+    }
+    const patch = this.createValuePatch(guid, input);
+
+    return this.mutate(async (manager) => {
+      const owners = manager.getRepository(OmniRecordEntity);
+      const extensions = manager.getRepository(this.repository.target);
+      const currentOwner = await this.findOwner(guid, manager);
+      const currentExtension = await extensions.findOne({
+        where: {
+          [this.definition.scope.column]: this.scope.scopeId,
+          [this.definition.identity.column]: guid,
+        } as any,
+      });
+      if (!currentOwner) this.notFound();
+      if (currentOwner.revision !== expectedRevision) {
+        await this.throwUpdateMiss(guid, manager);
+      }
+      if (!currentExtension) {
+        throw new Error(
+          'Omni extension projection invariant failed: extension row is unavailable.',
+        );
+      }
+      await this.lifecycle?.beforeUpdate?.({
+        definition: this.omniDefinition,
+        scope: this.scope,
+        manager,
+        readers: this.readers(manager),
+        input,
+        current: this.merge(currentExtension, currentOwner),
+      });
+      const result = await owners
+        .createQueryBuilder()
+        .update()
+        .set({ revision: () => '"revision" + 1' })
+        .where(
+          '"scopeId" = :scopeId AND "guid" = :guid AND "revision" = :expectedRevision AND "kind" = :kind AND "payloadSchemaId" = :schemaId AND "payloadSchemaVersion" = :schemaVersion AND "deletedAt" IS NULL',
+          {
+            scopeId: this.scope.scopeId,
+            guid,
+            expectedRevision,
+            kind: this.omniDefinition.owner.kind,
+            schemaId: this.omniDefinition.owner.schema.id,
+            schemaVersion: this.omniDefinition.owner.schema.version,
+          },
+        )
+        .execute();
+      if (!result.affected) await this.throwUpdateMiss(guid, manager);
+
+      const patched = await this.dialect.patchValues(
+        extensions,
+        this.definition,
+        patch,
+      );
+      if (patched !== 1) {
+        throw new Error(
+          'Omni extension projection invariant failed: extension row is unavailable.',
+        );
+      }
+      const extension = await extensions.findOneOrFail({
+        where: {
+          [this.definition.scope.column]: this.scope.scopeId,
+          [this.definition.identity.column]: guid,
+        } as any,
+      });
+      const owner = await owners.findOneOrFail({
+        where: { scopeId: this.scope.scopeId, guid },
+      });
+      return this.merge(extension, owner);
+    });
+  }
+
+  override async deleteEntity(
+    conditions: Record<string, unknown>,
+  ): Promise<boolean> {
+    const guid = this.guidFromConditions(conditions);
+    await this.mutate(async (manager) => {
+      const owner = await this.findOwner(guid, manager);
+      if (!owner) this.notFound();
+      const extension = await manager
+        .getRepository(this.repository.target)
+        .findOne({
+          where: {
+            [this.definition.scope.column]: this.scope.scopeId,
+            [this.definition.identity.column]: guid,
+          } as any,
+        });
+      if (!extension) {
+        throw new Error(
+          'Omni extension projection invariant failed: extension row is unavailable.',
+        );
+      }
+      await this.lifecycle?.beforeDelete?.({
+        definition: this.omniDefinition,
+        scope: this.scope,
+        manager,
+        readers: this.readers(manager),
+        input: {},
+        current: this.merge(extension, owner),
+      });
+      const result = await manager.getRepository(OmniRecordEntity).delete({
+        scopeId: this.scope.scopeId,
+        guid,
+        kind: this.omniDefinition.owner.kind,
+        payloadSchemaId: this.omniDefinition.owner.schema.id,
+        payloadSchemaVersion: this.omniDefinition.owner.schema.version,
+      });
+      if (!result.affected) this.notFound();
+    });
+    return true;
+  }
+
+  private createExtension(
+    input: Record<string, unknown>,
+  ): Record<string, unknown> {
+    const extension: Record<string, unknown> = {
+      [this.definition.scope.column]: this.scope.scopeId,
+      [this.definition.payload.column]: this.createPayload(input),
+    };
+    for (const field of this.definition.fields) {
+      const value = input[field.name];
+      if (field.requiredOnCreate && (value === undefined || value === null)) {
+        this.invalid(`Projection field ${field.name} is required on create.`);
+      }
+      if (value === null && !field.nullable) {
+        this.invalid(`Projection field ${field.name} cannot be null.`);
+      }
+      if (value !== undefined && field.storage === 'column') {
+        extension[field.column ?? field.name] = this.normalizeValue(
+          field,
+          value,
+        );
+      }
+    }
+    return extension;
+  }
+
+  private readers(manager: EntityManager) {
+    return (
+      this.readerCatalog ??
+      createOmniProjectionReaderCatalog([
+        {
+          type: 'extension',
+          id: this.omniDefinition.id,
+          entity: this.repository.target,
+          definition: this.omniDefinition,
+        },
+      ])
+    ).bind(manager, this.scope);
+  }
+
+  private async mutate<T>(
+    work: (manager: EntityManager) => Promise<T>,
+  ): Promise<T> {
+    try {
+      if (this.lifecycle) {
+        return await this.dataSource.transaction('SERIALIZABLE', work);
+      }
+      return await this.dataSource.transaction(work);
+    } catch (error) {
+      if (isRetryableTransactionError(error)) {
+        throw this.events.errorConflict(
+          'projection.concurrent.write.conflict',
+          {
+            response: {
+              message:
+                'Omni projection concurrent write conflict; retry the mutation.',
+            },
+          },
+        );
+      }
+      throw error;
+    }
+  }
+
+  private createValuePatch(
+    guid: string,
+    input: Record<string, unknown>,
+  ): ProjectionValuePatch {
+    const patch: ProjectionValuePatch = {
+      scopeId: this.scope.scopeId,
+      guid,
+      columnValues: {},
+      jsonValues: [],
+    };
+    for (const field of this.definition.fields) {
+      if (
+        field.name === this.definition.identity.column ||
+        !hasOwn(input, field.name)
+      ) {
+        continue;
+      }
+      const value = input[field.name];
+      if (value === null && !field.nullable) {
+        this.invalid(`Projection field ${field.name} cannot be null.`);
+      }
+      const normalized = this.normalizeValue(field, value);
+      if (field.storage === 'column') {
+        patch.columnValues[field.column ?? field.name] = normalized;
+      } else {
+        patch.jsonValues.push({ field, value: normalized });
+      }
+    }
+    if (
+      Object.keys(patch.columnValues).length === 0 &&
+      patch.jsonValues.length === 0
+    ) {
+      this.invalid('Projection update requires at least one writable field.');
+    }
+    return patch;
+  }
+
+  private async readOne(guid: string): Promise<Extension | null> {
+    const extension = await this.repository.findOne({
+      where: {
+        [this.definition.scope.column]: this.scope.scopeId,
+        [this.definition.identity.column]: guid,
+      } as any,
+    });
+    if (!extension) return null;
+    const owner = await this.findOwner(guid);
+    return owner ? this.merge(extension, owner) : null;
+  }
+
+  private async findOwner(
+    guid: string,
+    manager?: EntityManager,
+  ): Promise<OmniRecordEntity | null> {
+    return (
+      manager?.getRepository(OmniRecordEntity) ?? this.ownerRepository
+    ).findOne({
+      where: {
+        scopeId: this.scope.scopeId,
+        guid,
+        kind: this.omniDefinition.owner.kind,
+        payloadSchemaId: this.omniDefinition.owner.schema.id,
+        payloadSchemaVersion: this.omniDefinition.owner.schema.version,
+        deletedAt: IsNull(),
+      },
+    });
+  }
+
+  private merge(extension: Extension, owner: OmniRecordEntity): Extension {
+    return {
+      ...(this.project(extension) as Record<string, unknown>),
+      scopeId: owner.scopeId,
+      guid: owner.guid,
+      [this.definition.revision.column]: owner.revision,
+      createdAt: owner.createdAt,
+      updatedAt: owner.updatedAt,
+      deletedAt: owner.deletedAt,
+    } as unknown as Extension;
+  }
+
+  private async throwUpdateMiss(
+    guid: string,
+    manager: EntityManager,
+  ): Promise<never> {
+    if (!(await this.findOwner(guid, manager))) this.notFound();
+    throw this.events.errorConflict('projection.revision.conflict', {
+      response: { message: 'Projection resource revision is stale.' },
+    });
+  }
+
+  private identityConflict(): never {
+    throw this.events.errorConflict('projection.identity.conflict', {
+      response: {
+        message: 'Projection identity already exists in this scope.',
+      },
+    });
+  }
+}

package/src/omni-external-ref-binding.validator.d.ts

@@ -0,0 +1,14 @@
+import { type Repository } from 'typeorm';
+import { OmniRecordEntity } from './base/omni-record.entity.js';
+import { OmniExternalRefInternalType } from './omni-external-ref-internal-type.enum.js';
+import type { OmniScope } from './omni-scope.js';
+export interface OmniExternalRefBinding {
+    internalId: string;
+    internalType: OmniExternalRefInternalType;
+}
+export declare class OmniExternalRefBindingValidator {
+    private readonly recordRepository;
+    private readonly scope;
+    constructor(recordRepository: Repository<OmniRecordEntity>, scope: OmniScope);
+    assertTarget(binding: OmniExternalRefBinding): Promise<OmniRecordEntity>;
+}

package/src/omni-external-ref-binding.validator.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmniExternalRefBindingValidator = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const omni_external_ref_internal_type_enum_js_1 = require("./omni-external-ref-internal-type.enum.js");
+class OmniExternalRefBindingValidator {
+    constructor(recordRepository, scope) {
+        this.recordRepository = recordRepository;
+        this.scope = scope;
+    }
+    async assertTarget(binding) {
+        if (binding.internalType !== omni_external_ref_internal_type_enum_js_1.OmniExternalRefInternalType.Record) {
+            throw new common_1.BadRequestException('Omni external record binding must declare internalType record.');
+        }
+        if (typeof binding.internalId !== 'string' ||
+            binding.internalId.trim().length === 0) {
+            throw new common_1.BadRequestException('Omni external reference internalId must be a non-empty record identity.');
+        }
+        const record = await this.recordRepository.findOne({
+            where: {
+                scopeId: this.scope.scopeId,
+                guid: binding.internalId,
+                deletedAt: (0, typeorm_1.IsNull)(),
+            },
+        });
+        if (!record) {
+            throw new common_1.NotFoundException('Omni external reference target was not found in this scope.');
+        }
+        return record;
+    }
+}
+exports.OmniExternalRefBindingValidator = OmniExternalRefBindingValidator;
+//# sourceMappingURL=omni-external-ref-binding.validator.js.map

package/src/omni-external-ref-binding.validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omni-external-ref-binding.validator.js","sourceRoot":"","sources":["omni-external-ref-binding.validator.ts"],"names":[],"mappings":";;;AAAA,2CAAwE;AACxE,qCAAkD;AAElD,uGAAwF;AAaxF,MAAa,+BAA+B;IAC1C,YACmB,gBAA8C,EAC9C,KAAgB;QADhB,qBAAgB,GAAhB,gBAAgB,CAA8B;QAC9C,UAAK,GAAL,KAAK,CAAW;IAChC,CAAC;IAEJ,KAAK,CAAC,YAAY,CAChB,OAA+B;QAE/B,IAAI,OAAO,CAAC,YAAY,KAAK,qEAA2B,CAAC,MAAM,EAAE,CAAC;YAChE,MAAM,IAAI,4BAAmB,CAC3B,gEAAgE,CACjE,CAAC;QACJ,CAAC;QACD,IACE,OAAO,OAAO,CAAC,UAAU,KAAK,QAAQ;YACtC,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EACtC,CAAC;YACD,MAAM,IAAI,4BAAmB,CAC3B,yEAAyE,CAC1E,CAAC;QACJ,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC;YACjD,KAAK,EAAE;gBACL,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO;gBAC3B,IAAI,EAAE,OAAO,CAAC,UAAU;gBACxB,SAAS,EAAE,IAAA,gBAAM,GAAE;aACpB;SACF,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,0BAAiB,CACzB,6DAA6D,CAC9D,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AApCD,0EAoCC"}

package/src/omni-external-ref-binding.validator.ts

@@ -0,0 +1,53 @@
+import { BadRequestException, NotFoundException } from '@nestjs/common';
+import { IsNull, type Repository } from 'typeorm';
+import { OmniRecordEntity } from './base/omni-record.entity.js';
+import { OmniExternalRefInternalType } from './omni-external-ref-internal-type.enum.js';
+import type { OmniScope } from './omni-scope.js';
+
+export interface OmniExternalRefBinding {
+  internalId: string;
+  internalType: OmniExternalRefInternalType;
+}
+
+/**
+ * Reusable validation for an external reference whose declared target is an
+ * Omni record identity. Other internal types remain legacy application-owned
+ * identities and are intentionally not passed to this validator.
+ */
+export class OmniExternalRefBindingValidator {
+  constructor(
+    private readonly recordRepository: Repository<OmniRecordEntity>,
+    private readonly scope: OmniScope,
+  ) {}
+
+  async assertTarget(
+    binding: OmniExternalRefBinding,
+  ): Promise<OmniRecordEntity> {
+    if (binding.internalType !== OmniExternalRefInternalType.Record) {
+      throw new BadRequestException(
+        'Omni external record binding must declare internalType record.',
+      );
+    }
+    if (
+      typeof binding.internalId !== 'string' ||
+      binding.internalId.trim().length === 0
+    ) {
+      throw new BadRequestException(
+        'Omni external reference internalId must be a non-empty record identity.',
+      );
+    }
+    const record = await this.recordRepository.findOne({
+      where: {
+        scopeId: this.scope.scopeId,
+        guid: binding.internalId,
+        deletedAt: IsNull(),
+      },
+    });
+    if (!record) {
+      throw new NotFoundException(
+        'Omni external reference target was not found in this scope.',
+      );
+    }
+    return record;
+  }
+}

package/src/omni-external-ref-internal-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum OmniExternalRefInternalType {
+    Record = "record",
+    Document = "document",
+    Collection = "collection"
+}

package/src/omni-external-ref-internal-type.enum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmniExternalRefInternalType = void 0;
+const graphql_1 = require("@nestjs/graphql");
+var OmniExternalRefInternalType;
+(function (OmniExternalRefInternalType) {
+    OmniExternalRefInternalType["Record"] = "record";
+    OmniExternalRefInternalType["Document"] = "document";
+    OmniExternalRefInternalType["Collection"] = "collection";
+})(OmniExternalRefInternalType || (exports.OmniExternalRefInternalType = OmniExternalRefInternalType = {}));
+(0, graphql_1.registerEnumType)(OmniExternalRefInternalType, {
+    name: 'OmniExternalRefInternalType',
+});
+//# sourceMappingURL=omni-external-ref-internal-type.enum.js.map

package/src/omni-external-ref-internal-type.enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omni-external-ref-internal-type.enum.js","sourceRoot":"","sources":["omni-external-ref-internal-type.enum.ts"],"names":[],"mappings":";;;AAAA,6CAAmD;AAEnD,IAAY,2BAIX;AAJD,WAAY,2BAA2B;IACrC,gDAAiB,CAAA;IACjB,oDAAqB,CAAA;IACrB,wDAAyB,CAAA;AAC3B,CAAC,EAJW,2BAA2B,2CAA3B,2BAA2B,QAItC;AAED,IAAA,0BAAgB,EAAC,2BAA2B,EAAE;IAC5C,IAAI,EAAE,6BAA6B;CACpC,CAAC,CAAC"}

package/src/omni-external-ref-internal-type.enum.ts

@@ -0,0 +1,11 @@
+import { registerEnumType } from '@nestjs/graphql';
+
+export enum OmniExternalRefInternalType {
+  Record = 'record',
+  Document = 'document',
+  Collection = 'collection',
+}
+
+registerEnumType(OmniExternalRefInternalType, {
+  name: 'OmniExternalRefInternalType',
+});

package/src/omni-external-ref.backend.d.ts

@@ -0,0 +1,2 @@
+import { OmniExternalRefEntity } from './base/omni-external-ref.entity.js';
+export declare const omniExternalRefBackendProvidersFactory: (dbConnection: string) => import("./omni-scoped.backend.js").OmniScopedBackendFactoryResult<OmniExternalRefEntity>;

package/src/omni-external-ref.backend.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omniExternalRefBackendProvidersFactory = void 0;
+const typeorm_1 = require("@nestjs/typeorm");
+const omni_record_entity_js_1 = require("./base/omni-record.entity.js");
+const omni_external_ref_entity_js_1 = require("./base/omni-external-ref.entity.js");
+const omni_external_ref_binding_validator_js_1 = require("./omni-external-ref-binding.validator.js");
+const omni_external_ref_service_js_1 = require("./omni-external-ref.service.js");
+const omni_scoped_backend_js_1 = require("./omni-scoped.backend.js");
+const omniExternalRefBackendProvidersFactory = (dbConnection) => (0, omni_scoped_backend_js_1.omniScopedBackendProvidersFactory)({
+    entityModel: omni_external_ref_entity_js_1.OmniExternalRefEntity,
+    dbConnection,
+    serviceToken: (0, omni_scoped_backend_js_1.omniBackendServiceToken)(omni_external_ref_service_js_1.OmniExternalRefService),
+    serviceProvider: omni_external_ref_service_js_1.OmniExternalRefService,
+    additionalInject: [(0, typeorm_1.getRepositoryToken)(omni_record_entity_js_1.OmniRecordEntity, dbConnection)],
+    createService: (repository, scope, options, recordRepository) => new omni_external_ref_service_js_1.OmniExternalRefService(repository, scope, options.deletion.externalRef, new omni_external_ref_binding_validator_js_1.OmniExternalRefBindingValidator(recordRepository, scope)),
+});
+exports.omniExternalRefBackendProvidersFactory = omniExternalRefBackendProvidersFactory;
+//# sourceMappingURL=omni-external-ref.backend.js.map

package/src/omni-external-ref.backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omni-external-ref.backend.js","sourceRoot":"","sources":["omni-external-ref.backend.ts"],"names":[],"mappings":";;;AAAA,6CAAqD;AACrD,wEAAgE;AAChE,oFAA2E;AAC3E,qGAA2F;AAC3F,iFAAwE;AACxE,qEAGkC;AAE3B,MAAM,sCAAsC,GAAG,CAAC,YAAoB,EAAE,EAAE,CAC7E,IAAA,0DAAiC,EAAwB;IACvD,WAAW,EAAE,mDAAqB;IAClC,YAAY;IACZ,YAAY,EAAE,IAAA,gDAAuB,EAAC,qDAAsB,CAAC;IAC7D,eAAe,EAAE,qDAAsB;IACvC,gBAAgB,EAAE,CAAC,IAAA,4BAAkB,EAAC,wCAAgB,EAAE,YAAY,CAAC,CAAC;IACtE,aAAa,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,EAAE,CAC9D,IAAI,qDAAsB,CACxB,UAAU,EACV,KAAK,EACL,OAAO,CAAC,QAAQ,CAAC,WAAW,EAC5B,IAAI,wEAA+B,CAAC,gBAAyB,EAAE,KAAK,CAAC,CACtE;CACJ,CAAC,CAAC;AAdQ,QAAA,sCAAsC,0CAc9C"}

package/src/omni-external-ref.backend.ts

@@ -0,0 +1,25 @@
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { OmniRecordEntity } from './base/omni-record.entity.js';
+import { OmniExternalRefEntity } from './base/omni-external-ref.entity.js';
+import { OmniExternalRefBindingValidator } from './omni-external-ref-binding.validator.js';
+import { OmniExternalRefService } from './omni-external-ref.service.js';
+import {
+  omniBackendServiceToken,
+  omniScopedBackendProvidersFactory,
+} from './omni-scoped.backend.js';
+
+export const omniExternalRefBackendProvidersFactory = (dbConnection: string) =>
+  omniScopedBackendProvidersFactory<OmniExternalRefEntity>({
+    entityModel: OmniExternalRefEntity,
+    dbConnection,
+    serviceToken: omniBackendServiceToken(OmniExternalRefService),
+    serviceProvider: OmniExternalRefService,
+    additionalInject: [getRepositoryToken(OmniRecordEntity, dbConnection)],
+    createService: (repository, scope, options, recordRepository) =>
+      new OmniExternalRefService(
+        repository,
+        scope,
+        options.deletion.externalRef,
+        new OmniExternalRefBindingValidator(recordRepository as never, scope),
+      ),
+  });

package/src/omni-external-ref.dto.d.ts

@@ -0,0 +1,26 @@
+import { OmniExternalRefEntity } from './base/omni-external-ref.entity.js';
+import { OmniExternalRefInternalType } from './omni-external-ref-internal-type.enum.js';
+export declare class OmniExternalRefType extends OmniExternalRefEntity {
+    constructor(data?: Partial<OmniExternalRefType>);
+    guid: string;
+    revision: number;
+    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;
+}
+declare const OmniExternalRefCreateInput_base: import("@nestjs/common").Type<Omit<OmniExternalRefType, "revision" | "createdAt" | "updatedAt">>;
+export declare class OmniExternalRefCreateInput extends OmniExternalRefCreateInput_base {
+}
+declare const OmniExternalRefCondition_base: import("@nestjs/common").Type<Partial<OmniExternalRefCreateInput>>;
+export declare class OmniExternalRefCondition extends OmniExternalRefCondition_base {
+}
+declare const OmniExternalRefUpdateInput_base: import("@nestjs/common").Type<Partial<OmniExternalRefCreateInput>>;
+export declare class OmniExternalRefUpdateInput extends OmniExternalRefUpdateInput_base {
+}
+export {};