@nest-yalc-2/omnikernel-module 1.1.0

package/src/omni-migration.ts

@@ -0,0 +1,365 @@
+import type { DataSource, EntityTarget, ObjectLiteral } from 'typeorm';
+import { Table, TableForeignKey, type TableOptions } from 'typeorm';
+import {
+  createProjectionDialect,
+  type ProjectionResourceDefinition,
+} from '@nest-yalc-2/crud-gen';
+import { OmniExternalRefEntity } from './base/omni-external-ref.entity.js';
+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';
+
+export interface OmniMigrationSnapshot {
+  /** A migration-owned identifier, for example `omni-v1`. */
+  readonly version: string;
+  /** The driver whose physical column types were captured. */
+  readonly dialect: 'sqlite' | 'postgres';
+  /** Immutable, serializable TypeORM TableOptions captured during authoring. */
+  readonly tables: readonly TableOptions[];
+  /** Immutable ProjectionDialect DDL for JSON/expression indexes. */
+  readonly indexStatements: readonly string[];
+}
+
+/**
+ * The portable subset of a migration runner used by an Omni migration plan.
+ *
+ * It deliberately does not reference TypeORM's `QueryRunner` type. A package
+ * manager may give the module and a consuming migration distinct physical
+ * TypeORM installations, even at the same version; exposing that branded
+ * framework type would then reject the application's runner. TypeORM runners
+ * satisfy this structural capability contract without a consumer cast.
+ */
+export interface OmniMigrationRunner {
+  createTable(
+    table: unknown,
+    ifNotExist?: boolean,
+    createForeignKeys?: boolean,
+    createIndices?: boolean,
+  ): Promise<void>;
+  query(statement: string): Promise<unknown>;
+}
+
+export interface OmniMigrationPlan {
+  readonly version: string;
+  readonly tableNames: readonly string[];
+  /** Dialect-compiled index DDL that the plan executes after all tables exist. */
+  readonly indexStatements: readonly string[];
+  /** Returns fresh mutable Table instances from the versioned source snapshot. */
+  createTables(): Table[];
+  /** Intended only from a TypeORM migration up() method. */
+  create(queryRunner: OmniMigrationRunner): Promise<void>;
+  /** Intended only from a TypeORM migration down() method. */
+  drop(queryRunner: OmniMigrationRunner): Promise<void>;
+}
+
+/**
+ * The migration-relevant subset of a registered extension composition. It
+ * keeps schema authoring tied to the same immutable projection definition as
+ * the generated transport and service, without making runtime metadata a
+ * migration dependency.
+ */
+export interface OmniMigrationExtensionRegistration {
+  readonly entities: readonly EntityTarget<any>[];
+  readonly definition: ProjectionResourceDefinition;
+}
+
+const omniBaseEntities = [
+  OmniNamedEntity,
+  OmniRecordEntity,
+  OmniDocumentEntity,
+  OmniCollectionEntity,
+  OmniRelationEntity,
+  OmniExternalRefEntity,
+] as const;
+
+function freezeDeep<T>(value: T): T {
+  if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+    for (const child of Object.values(value as Record<string, unknown>)) {
+      freezeDeep(child);
+    }
+    Object.freeze(value);
+  }
+  return value;
+}
+
+function dialectFor(dataSource: DataSource): 'sqlite' | 'postgres' {
+  if (dataSource.options.type === 'sqlite') return 'sqlite';
+  if (dataSource.options.type === 'postgres') return 'postgres';
+  throw new TypeError('Omni migration snapshots support SQLite or PostgreSQL.');
+}
+
+function tableOptions(table: Table): TableOptions {
+  return {
+    database: table.database,
+    schema: table.schema,
+    name: table.name,
+    withoutRowid: table.withoutRowid,
+    engine: table.engine,
+    comment: table.comment,
+    columns: table.columns.map((column) => ({
+      name: column.name,
+      type: column.type,
+      default: column.default,
+      onUpdate: column.onUpdate,
+      isNullable: column.isNullable,
+      isGenerated: column.isGenerated,
+      generationStrategy: column.generationStrategy,
+      isPrimary: column.isPrimary,
+      isUnique: column.isUnique,
+      isArray: column.isArray,
+      comment: column.comment,
+      length: column.length,
+      width: column.width,
+      charset: column.charset,
+      collation: column.collation,
+      precision: column.precision,
+      scale: column.scale,
+      zerofill: column.zerofill,
+      unsigned: column.unsigned,
+      enum: column.enum ? [...column.enum] : undefined,
+      enumName: column.enumName,
+      primaryKeyConstraintName: column.primaryKeyConstraintName,
+      asExpression: column.asExpression,
+      generatedType: column.generatedType,
+      generatedIdentity: column.generatedIdentity,
+      spatialFeatureType: column.spatialFeatureType,
+      srid: column.srid,
+    })),
+    indices: table.indices.map((index) => ({
+      name: index.name,
+      columnNames: [...index.columnNames],
+      isUnique: index.isUnique,
+      isSpatial: index.isSpatial,
+      isConcurrent: index.isConcurrent,
+      isFulltext: index.isFulltext,
+      isNullFiltered: index.isNullFiltered,
+      parser: index.parser,
+      where: index.where,
+    })),
+    foreignKeys: table.foreignKeys.map((foreignKey) => ({
+      name: foreignKey.name,
+      columnNames: [...foreignKey.columnNames],
+      referencedDatabase: foreignKey.referencedDatabase,
+      referencedSchema: foreignKey.referencedSchema,
+      referencedTableName: foreignKey.referencedTableName,
+      referencedColumnNames: [...foreignKey.referencedColumnNames],
+      onDelete: foreignKey.onDelete,
+      onUpdate: foreignKey.onUpdate,
+      deferrable: foreignKey.deferrable,
+    })),
+    uniques: table.uniques.map((unique) => ({
+      name: unique.name,
+      columnNames: [...unique.columnNames],
+      deferrable: unique.deferrable,
+    })),
+    checks: table.checks.map((check) => ({
+      name: check.name,
+      columnNames: check.columnNames ? [...check.columnNames] : undefined,
+      expression: check.expression,
+    })),
+    exclusions: table.exclusions.map((exclusion) => ({
+      name: exclusion.name,
+      expression: exclusion.expression,
+    })),
+  };
+}
+
+function tableSnapshots(
+  dataSource: DataSource,
+  entities: readonly EntityTarget<ObjectLiteral>[],
+): TableOptions[] {
+  const byTableName = new Map<string, Table>();
+  for (const entity of entities) {
+    const metadata = dataSource.getMetadata(entity);
+    const table = Table.create(metadata, dataSource.driver);
+    table.foreignKeys = metadata.foreignKeys.map((foreignKey) =>
+      TableForeignKey.create(foreignKey, dataSource.driver),
+    );
+    const current = byTableName.get(table.name);
+    if (!current || current.columns.length < table.columns.length) {
+      byTableName.set(table.name, table);
+    }
+  }
+
+  return orderTablesTopologically([...byTableName.values()].map(tableOptions));
+}
+
+/**
+ * Orders a complete migration snapshot from FK parents to children. A
+ * migration may not defer this to registration order: PostgreSQL requires the
+ * referenced table to exist at FK creation time. Self references are valid;
+ * cross-table cycles are rejected during migration authoring.
+ */
+function orderTablesTopologically(
+  tables: readonly TableOptions[],
+): TableOptions[] {
+  const byName = new Map<string, TableOptions>();
+  for (const table of tables) {
+    if (!table.name)
+      throw new TypeError('Omni migration table name is required.');
+    byName.set(table.name, table);
+  }
+  const dependencies = new Map<string, Set<string>>();
+  for (const table of tables) {
+    const tableName = table.name!;
+    const parents = new Set<string>();
+    for (const foreignKey of table.foreignKeys ?? []) {
+      const parent = foreignKey.referencedTableName;
+      if (!parent || parent === tableName) continue;
+      if (!byName.has(parent)) {
+        throw new TypeError(
+          `Omni migration table ${tableName} references ${parent}, which is absent from this snapshot.`,
+        );
+      }
+      parents.add(parent);
+    }
+    dependencies.set(tableName, parents);
+  }
+  const remaining = new Map(
+    [...dependencies.entries()].map(([name, parents]) => [
+      name,
+      new Set(parents),
+    ]),
+  );
+  const ordered: TableOptions[] = [];
+  while (remaining.size > 0) {
+    const ready = tables.filter(
+      (table) =>
+        table.name !== undefined && remaining.get(table.name)?.size === 0,
+    );
+    if (ready.length === 0) {
+      throw new TypeError(
+        `Omni migration snapshot has a cross-table foreign-key cycle: ${[
+          ...remaining.keys(),
+        ].join(', ')}.`,
+      );
+    }
+    for (const table of ready) {
+      const name = table.name!;
+      remaining.delete(name);
+      ordered.push(table);
+      for (const parents of remaining.values()) parents.delete(name);
+    }
+  }
+  return ordered;
+}
+
+function quotedIdentifier(identifier: string): string {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+
+function quotedTableName(table: TableOptions): string {
+  if (!table.name)
+    throw new TypeError('Omni migration table name is required.');
+  return [table.schema, table.name]
+    .filter(
+      (part): part is string => typeof part === 'string' && part.length > 0,
+    )
+    .map(quotedIdentifier)
+    .join('.');
+}
+
+/**
+ * Authoring-only helper. Run this against a metadata-only DataSource and copy
+ * the returned value into a versioned migration source using
+ * defineOmniMigrationSnapshot. Never invoke it from a migration at runtime.
+ */
+export function captureOmniMigrationSnapshot(
+  version: string,
+  dataSource: DataSource,
+  extensions: readonly OmniMigrationExtensionRegistration[] = [],
+): OmniMigrationSnapshot {
+  const dialect = dialectFor(dataSource);
+  return defineOmniMigrationSnapshot({
+    version,
+    dialect,
+    tables: tableSnapshots(dataSource, [
+      ...omniBaseEntities,
+      ...extensions.flatMap((extension) => extension.entities),
+    ]),
+    indexStatements: extensions.flatMap((extension) =>
+      createProjectionDialect(dialect).compileIndexStatements(
+        extension.definition,
+      ),
+    ),
+  });
+}
+
+/**
+ * Freezes a migration-owned table snapshot. Old migration source calls this
+ * with a literal captured at authoring time, so future entity changes cannot
+ * alter its DDL.
+ */
+export function defineOmniMigrationSnapshot(
+  snapshot: OmniMigrationSnapshot,
+): OmniMigrationSnapshot {
+  if (
+    typeof snapshot.version !== 'string' ||
+    snapshot.version.trim().length === 0
+  ) {
+    throw new TypeError('Omni migration snapshot version is required.');
+  }
+  if (snapshot.dialect !== 'sqlite' && snapshot.dialect !== 'postgres') {
+    throw new TypeError('Omni migration snapshot dialect is unsupported.');
+  }
+  if (!Array.isArray(snapshot.tables) || snapshot.tables.length === 0) {
+    throw new TypeError('Omni migration snapshot requires at least one table.');
+  }
+  const names = snapshot.tables.map((table) => table.name);
+  if (
+    names.some((name) => typeof name !== 'string' || name.length === 0) ||
+    new Set(names).size !== names.length
+  ) {
+    throw new TypeError('Omni migration snapshot table names must be unique.');
+  }
+  if (
+    !Array.isArray(snapshot.indexStatements) ||
+    snapshot.indexStatements.some(
+      (statement) =>
+        typeof statement !== 'string' || statement.trim().length === 0,
+    ) ||
+    new Set(snapshot.indexStatements).size !== snapshot.indexStatements.length
+  ) {
+    throw new TypeError(
+      'Omni migration snapshot index statements must be unique non-empty strings.',
+    );
+  }
+  return freezeDeep(structuredClone(snapshot));
+}
+
+/**
+ * Creates a migration executor from an already-versioned snapshot. This API
+ * deliberately accepts no DataSource or entity classes: runtime metadata is
+ * never a migration authority.
+ */
+export function createOmniMigrationPlan(
+  snapshot: OmniMigrationSnapshot,
+): OmniMigrationPlan {
+  const source = defineOmniMigrationSnapshot(snapshot);
+  const tables = orderTablesTopologically(source.tables);
+
+  return Object.freeze({
+    version: source.version,
+    tableNames: Object.freeze(tables.map((table) => table.name)),
+    indexStatements: Object.freeze([...source.indexStatements]),
+    createTables: () =>
+      tables.map((table) => new Table(structuredClone(table))),
+    create: async (queryRunner: OmniMigrationRunner) => {
+      for (const table of tables) {
+        await queryRunner.createTable(new Table(structuredClone(table)));
+      }
+      for (const statement of source.indexStatements) {
+        await queryRunner.query(statement);
+      }
+    },
+    drop: async (queryRunner: OmniMigrationRunner) => {
+      for (const table of [...tables].reverse()) {
+        await queryRunner.query(
+          `DROP TABLE IF EXISTS ${quotedTableName(table)}`,
+        );
+      }
+    },
+  });
+}

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

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

package/src/omni-named.backend.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omniNamedBackendProvidersFactory = void 0;
+const omni_named_entity_js_1 = require("./base/omni-named.entity.js");
+const omni_scoped_backend_js_1 = require("./omni-scoped.backend.js");
+const omni_scoped_service_js_1 = require("./omni-scoped.service.js");
+const omniNamedBackendProvidersFactory = (dbConnection) => (0, omni_scoped_backend_js_1.omniScopedBackendProvidersFactory)({
+    entityModel: omni_named_entity_js_1.OmniNamedEntity,
+    dbConnection,
+    createService: (repository, scope, options) => new omni_scoped_service_js_1.OmniScopedService(repository, scope, options.deletion.named),
+});
+exports.omniNamedBackendProvidersFactory = omniNamedBackendProvidersFactory;
+//# sourceMappingURL=omni-named.backend.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"omni-named.backend.js","sourceRoot":"","sources":["omni-named.backend.ts"],"names":[],"mappings":";;;AAAA,sEAA8D;AAC9D,qEAA6E;AAC7E,qEAA6D;AAEtD,MAAM,gCAAgC,GAAG,CAAC,YAAoB,EAAE,EAAE,CACvE,IAAA,0DAAiC,EAAkB;IACjD,WAAW,EAAE,sCAAe;IAC5B,YAAY;IACZ,aAAa,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,CAC5C,IAAI,0CAAiB,CAAC,UAAU,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;CACnE,CAAC,CAAC;AANQ,QAAA,gCAAgC,oCAMxC"}

package/src/omni-named.backend.ts

@@ -0,0 +1,11 @@
+import { OmniNamedEntity } from './base/omni-named.entity.js';
+import { omniScopedBackendProvidersFactory } from './omni-scoped.backend.js';
+import { OmniScopedService } from './omni-scoped.service.js';
+
+export const omniNamedBackendProvidersFactory = (dbConnection: string) =>
+  omniScopedBackendProvidersFactory<OmniNamedEntity>({
+    entityModel: OmniNamedEntity,
+    dbConnection,
+    createService: (repository, scope, options) =>
+      new OmniScopedService(repository, scope, options.deletion.named),
+  });

package/src/omni-named.dto.d.ts

@@ -0,0 +1,19 @@
+import { OmniNamedEntity } from './base/omni-named.entity.js';
+export declare class OmniNamedType extends OmniNamedEntity {
+    constructor(data?: Partial<OmniNamedType>);
+    guid: string;
+    revision: number;
+    externalId?: string | null;
+    title: string;
+    slug?: string | null;
+}
+declare const OmniNamedCreateInput_base: import("@nestjs/common").Type<Omit<OmniNamedType, "revision" | "createdAt" | "updatedAt">>;
+export declare class OmniNamedCreateInput extends OmniNamedCreateInput_base {
+}
+declare const OmniNamedCondition_base: import("@nestjs/common").Type<Partial<OmniNamedCreateInput>>;
+export declare class OmniNamedCondition extends OmniNamedCondition_base {
+}
+declare const OmniNamedUpdateInput_base: import("@nestjs/common").Type<Partial<OmniNamedCreateInput>>;
+export declare class OmniNamedUpdateInput extends OmniNamedUpdateInput_base {
+}
+export {};

package/src/omni-named.dto.js

@@ -0,0 +1,94 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OmniNamedUpdateInput = exports.OmniNamedCondition = exports.OmniNamedCreateInput = exports.OmniNamedType = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const object_decorator_js_1 = require("@nest-yalc-2/crud-gen/object.decorator.js");
+const uuid_scalar_js_1 = require("@nest-yalc-2/graphql/scalars/uuid.scalar.js");
+const returnValue_js_1 = __importDefault(require("@nest-yalc-2/utils/returnValue.js"));
+const class_validator_1 = require("class-validator");
+const omni_named_entity_js_1 = require("./base/omni-named.entity.js");
+const omni_dto_helpers_js_1 = require("./omni-dto.helpers.js");
+let OmniNamedType = class OmniNamedType extends omni_named_entity_js_1.OmniNamedEntity {
+    constructor(data) {
+        super();
+        if (data) {
+            (0, omni_dto_helpers_js_1.assignOmniPublicDto)(this, data);
+        }
+    }
+};
+exports.OmniNamedType = OmniNamedType;
+__decorate([
+    (0, object_decorator_js_1.ModelField)({ gqlType: (0, returnValue_js_1.default)(uuid_scalar_js_1.UUIDScalar), isRequired: true }),
+    (0, class_validator_1.IsUUID)(),
+    __metadata("design:type", String)
+], OmniNamedType.prototype, "guid", void 0);
+__decorate([
+    (0, object_decorator_js_1.ModelField)({ gqlType: (0, returnValue_js_1.default)(graphql_1.Int) }),
+    (0, class_validator_1.IsInt)(),
+    __metadata("design:type", Number)
+], OmniNamedType.prototype, "revision", void 0);
+__decorate([
+    (0, object_decorator_js_1.ModelField)({
+        gqlType: (0, returnValue_js_1.default)(String),
+        gqlOptions: { nullable: true },
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(128),
+    __metadata("design:type", Object)
+], OmniNamedType.prototype, "externalId", void 0);
+__decorate([
+    (0, object_decorator_js_1.ModelField)({ gqlType: (0, returnValue_js_1.default)(String) }),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(255),
+    __metadata("design:type", String)
+], OmniNamedType.prototype, "title", void 0);
+__decorate([
+    (0, object_decorator_js_1.ModelField)({
+        gqlType: (0, returnValue_js_1.default)(String),
+        gqlOptions: { nullable: true },
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(255),
+    __metadata("design:type", Object)
+], OmniNamedType.prototype, "slug", void 0);
+exports.OmniNamedType = OmniNamedType = __decorate([
+    (0, graphql_1.ObjectType)(),
+    (0, object_decorator_js_1.ModelObject)(),
+    __metadata("design:paramtypes", [Object])
+], OmniNamedType);
+let OmniNamedCreateInput = class OmniNamedCreateInput extends (0, graphql_1.OmitType)(OmniNamedType, ['createdAt', 'updatedAt', 'revision'], graphql_1.InputType) {
+};
+exports.OmniNamedCreateInput = OmniNamedCreateInput;
+exports.OmniNamedCreateInput = OmniNamedCreateInput = __decorate([
+    (0, graphql_1.InputType)(),
+    (0, object_decorator_js_1.ModelObject)()
+], OmniNamedCreateInput);
+let OmniNamedCondition = class OmniNamedCondition extends (0, graphql_1.PartialType)(OmniNamedCreateInput, graphql_1.InputType) {
+};
+exports.OmniNamedCondition = OmniNamedCondition;
+exports.OmniNamedCondition = OmniNamedCondition = __decorate([
+    (0, graphql_1.InputType)(),
+    (0, object_decorator_js_1.ModelObject)({ copyFrom: OmniNamedType })
+], OmniNamedCondition);
+let OmniNamedUpdateInput = class OmniNamedUpdateInput extends (0, graphql_1.PartialType)(OmniNamedCreateInput, graphql_1.InputType) {
+};
+exports.OmniNamedUpdateInput = OmniNamedUpdateInput;
+exports.OmniNamedUpdateInput = OmniNamedUpdateInput = __decorate([
+    (0, graphql_1.InputType)(),
+    (0, object_decorator_js_1.ModelObject)({ copyFrom: OmniNamedType })
+], OmniNamedUpdateInput);
+//# sourceMappingURL=omni-named.dto.js.map

package/src/omni-named.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"omni-named.dto.js","sourceRoot":"","sources":["omni-named.dto.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,6CAMyB;AACzB,mFAGmD;AACnD,gFAAyE;AACzE,uFAA4D;AAC5D,qDAMyB;AACzB,sEAA8D;AAC9D,+DAA4D;AAIrD,IAAM,aAAa,GAAnB,MAAM,aAAc,SAAQ,sCAAe;IAChD,YAAY,IAA6B;QACvC,KAAK,EAAE,CAAC;QACR,IAAI,IAAI,EAAE,CAAC;YACT,IAAA,yCAAmB,EAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;CAgCF,CAAA;AAtCY,sCAAa;AAUxB;IAFC,IAAA,gCAAU,EAAC,EAAE,OAAO,EAAE,IAAA,wBAAW,EAAC,2BAAU,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC;IAClE,IAAA,wBAAM,GAAE;;2CACK;AAId;IAFC,IAAA,gCAAU,EAAC,EAAE,OAAO,EAAE,IAAA,wBAAW,EAAC,aAAG,CAAC,EAAE,CAAC;IACzC,IAAA,uBAAK,GAAE;;+CACU;AASlB;IAPC,IAAA,gCAAU,EAAC;QACV,OAAO,EAAE,IAAA,wBAAW,EAAC,MAAM,CAAC;QAC5B,UAAU,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;KAC/B,CAAC;IACD,IAAA,4BAAU,GAAE;IACZ,IAAA,0BAAQ,GAAE;IACV,IAAA,2BAAS,EAAC,GAAG,CAAC;;iDACY;AAK3B;IAHC,IAAA,gCAAU,EAAC,EAAE,OAAO,EAAE,IAAA,wBAAW,EAAC,MAAM,CAAC,EAAE,CAAC;IAC5C,IAAA,0BAAQ,GAAE;IACV,IAAA,2BAAS,EAAC,GAAG,CAAC;;4CACA;AASf;IAPC,IAAA,gCAAU,EAAC;QACV,OAAO,EAAE,IAAA,wBAAW,EAAC,MAAM,CAAC;QAC5B,UAAU,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;KAC/B,CAAC;IACD,IAAA,4BAAU,GAAE;IACZ,IAAA,0BAAQ,GAAE;IACV,IAAA,2BAAS,EAAC,GAAG,CAAC;;2CACM;wBArCV,aAAa;IAFzB,IAAA,oBAAU,GAAE;IACZ,IAAA,iCAAW,GAAE;;GACD,aAAa,CAsCzB;AAIM,IAAM,oBAAoB,GAA1B,MAAM,oBAAqB,SAAQ,IAAA,kBAAQ,EAChD,aAAa,EACb,CAAC,WAAW,EAAE,WAAW,EAAE,UAAU,CAAU,EAC/C,mBAAS,CACV;CAAG,CAAA;AAJS,oDAAoB;+BAApB,oBAAoB;IAFhC,IAAA,mBAAS,GAAE;IACX,IAAA,iCAAW,GAAE;GACD,oBAAoB,CAI7B;AAIG,IAAM,kBAAkB,GAAxB,MAAM,kBAAmB,SAAQ,IAAA,qBAAW,EACjD,oBAAoB,EACpB,mBAAS,CACV;CAAG,CAAA;AAHS,gDAAkB;6BAAlB,kBAAkB;IAF9B,IAAA,mBAAS,GAAE;IACX,IAAA,iCAAW,EAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAC;GAC5B,kBAAkB,CAG3B;AAIG,IAAM,oBAAoB,GAA1B,MAAM,oBAAqB,SAAQ,IAAA,qBAAW,EACnD,oBAAoB,EACpB,mBAAS,CACV;CAAG,CAAA;AAHS,oDAAoB;+BAApB,oBAAoB;IAFhC,IAAA,mBAAS,GAAE;IACX,IAAA,iCAAW,EAAC,EAAE,QAAQ,EAAE,aAAa,EAAE,CAAC;GAC5B,oBAAoB,CAG7B"}

package/src/omni-named.dto.ts

@@ -0,0 +1,86 @@
+import {
+  InputType,
+  Int,
+  ObjectType,
+  OmitType,
+  PartialType,
+} from '@nestjs/graphql';
+import {
+  ModelField,
+  ModelObject,
+} from '@nest-yalc-2/crud-gen/object.decorator.js';
+import { UUIDScalar } from '@nest-yalc-2/graphql/scalars/uuid.scalar.js';
+import returnValue from '@nest-yalc-2/utils/returnValue.js';
+import {
+  IsInt,
+  IsOptional,
+  IsString,
+  IsUUID,
+  MaxLength,
+} from 'class-validator';
+import { OmniNamedEntity } from './base/omni-named.entity.js';
+import { assignOmniPublicDto } from './omni-dto.helpers.js';
+
+@ObjectType()
+@ModelObject()
+export class OmniNamedType extends OmniNamedEntity {
+  constructor(data?: Partial<OmniNamedType>) {
+    super();
+    if (data) {
+      assignOmniPublicDto(this, data);
+    }
+  }
+
+  @ModelField({ gqlType: returnValue(UUIDScalar), isRequired: true })
+  @IsUUID()
+  guid!: string;
+
+  @ModelField({ gqlType: returnValue(Int) })
+  @IsInt()
+  revision!: number;
+
+  @ModelField({
+    gqlType: returnValue(String),
+    gqlOptions: { nullable: true },
+  })
+  @IsOptional()
+  @IsString()
+  @MaxLength(128)
+  externalId?: string | null;
+
+  @ModelField({ gqlType: returnValue(String) })
+  @IsString()
+  @MaxLength(255)
+  title!: string;
+
+  @ModelField({
+    gqlType: returnValue(String),
+    gqlOptions: { nullable: true },
+  })
+  @IsOptional()
+  @IsString()
+  @MaxLength(255)
+  slug?: string | null;
+}
+
+@InputType()
+@ModelObject()
+export class OmniNamedCreateInput extends OmitType(
+  OmniNamedType,
+  ['createdAt', 'updatedAt', 'revision'] as const,
+  InputType,
+) {}
+
+@InputType()
+@ModelObject({ copyFrom: OmniNamedType })
+export class OmniNamedCondition extends PartialType(
+  OmniNamedCreateInput,
+  InputType,
+) {}
+
+@InputType()
+@ModelObject({ copyFrom: OmniNamedType })
+export class OmniNamedUpdateInput extends PartialType(
+  OmniNamedCreateInput,
+  InputType,
+) {}

package/src/omni-projection.catalog.d.ts

@@ -0,0 +1,49 @@
+import type { InjectionToken, Provider } from '@nestjs/common';
+import { type EntityManager, type EntityTarget, type ObjectLiteral } from 'typeorm';
+import { OmniRelationEntity } from './base/omni-relation.entity.js';
+import type { OmniExtensionProjectionDefinition } from './omni-extension-projection.definition.js';
+import { type OmniRelationProjectionDefinition } from './omni-relation-projection.definition.js';
+import type { OmniScope } from './omni-scope.js';
+export interface OmniExtensionProjectionReaderRegistration<Entity extends ObjectLiteral = ObjectLiteral> {
+    readonly type: 'extension';
+    readonly id: string;
+    readonly entity: EntityTarget<Entity>;
+    readonly definition: OmniExtensionProjectionDefinition;
+}
+export interface OmniRelationProjectionReaderRegistration {
+    readonly type: 'relation';
+    readonly id: string;
+    readonly definition: OmniRelationProjectionDefinition;
+}
+export type OmniProjectionReaderRegistration = OmniExtensionProjectionReaderRegistration | OmniRelationProjectionReaderRegistration;
+export interface OmniExtensionProjectionReader<Entity extends ObjectLiteral = ObjectLiteral> {
+    get(guid: string): Promise<Entity | undefined>;
+    list(options?: {
+        where?: Readonly<Record<string, unknown>>;
+        take?: number;
+    }): Promise<Entity[]>;
+}
+export interface OmniRelationProjectionReader {
+    get(guid: string): Promise<OmniRelationEntity | undefined>;
+    list(options?: {
+        sourceRecordId?: string;
+        targetRecordId?: string;
+        take?: number;
+    }): Promise<OmniRelationEntity[]>;
+}
+export interface OmniProjectionTransactionReaders {
+    extension<Entity extends ObjectLiteral = ObjectLiteral>(id: string): OmniExtensionProjectionReader<Entity>;
+    relation(id: string): OmniRelationProjectionReader;
+}
+export interface OmniProjectionReaderCatalog {
+    bind(manager: EntityManager, scope: OmniScope): OmniProjectionTransactionReaders;
+}
+export interface OmniProjectionReaderCatalogProvider {
+    readonly token: InjectionToken<OmniProjectionReaderCatalog>;
+}
+export interface OmniProjectionReaderCatalogSource {
+    readonly reader: OmniProjectionReaderRegistration;
+}
+export declare const OMNI_PROJECTION_READER_CATALOG: unique symbol;
+export declare function createOmniProjectionReaderCatalog(registrations: readonly (OmniProjectionReaderRegistration | OmniProjectionReaderCatalogSource)[]): OmniProjectionReaderCatalog;
+export declare function createOmniProjectionReaderCatalogProvider(registrations: readonly (OmniProjectionReaderRegistration | OmniProjectionReaderCatalogSource)[], token?: InjectionToken<OmniProjectionReaderCatalog>): Provider;