@decaf-ts/for-typeorm 0.0.6

package/lib/esm/TypeORMRepository.js

@@ -0,0 +1,206 @@
+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);
+};
+import { ModelKeys, } from "@decaf-ts/decorator-validation";
+import { Repository, uses } from "@decaf-ts/core";
+import { Context, enforceDBDecorators, OperationKeys, ValidationError, } from "@decaf-ts/db-decorators";
+import { TypeORMAdapter } from "./TypeORMAdapter.js";
+import { TypeORMFlavour } from "./constants.js";
+/**
+ * @description Repository implementation backed by TypeORM.
+ * @summary Provides CRUD operations for a given Model using the {@link TypeORMAdapter}, including bulk operations and query builder access while preserving Decaf.ts repository semantics.
+ * @template M Type extending Model that this repository will manage.
+ * @param {TypeORMAdapter} adapter The adapter used to execute persistence operations.
+ * @param {Constructor<M>} model The Model constructor associated with this repository.
+ * @param {...any[]} args Optional arguments forwarded to the base Repository.
+ * @class TypeORMRepository
+ * @example
+ * // Creating a repository
+ * const repo = new TypeORMRepository<User>(adapter, User);
+ * const created = await repo.create(new User({ name: "Alice" }));
+ * const read = await repo.read(created.id);
+ *
+ * // Bulk create
+ * await repo.createAll([new User({ name: "A" }), new User({ name: "B" })]);
+ *
+ * // Using the query builder
+ * const qb = repo.queryBuilder();
+ * const rows = await qb.where("name = :name", { name: "Alice" }).getMany();
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Repo as TypeORMRepository
+ *   participant Adapter as TypeORMAdapter
+ *   participant DB as TypeORM/DataSource
+ *
+ *   App->>Repo: create(model)
+ *   Repo->>Adapter: prepare(model, pk)
+ *   Adapter-->>Repo: { record, id, transient }
+ *   Repo->>Adapter: create(table, id, model, ...args)
+ *   Adapter->>DB: INSERT ...
+ *   DB-->>Adapter: row
+ *   Adapter-->>Repo: row
+ *   Repo->>Adapter: revert(row, clazz, pk, id)
+ *   Adapter-->>Repo: model
+ *   Repo-->>App: model
+ */
+let TypeORMRepository = class TypeORMRepository extends Repository {
+    constructor(adapter, model, ...args) {
+        super(adapter, model, ...args);
+    }
+    /**
+     * @description Creates a TypeORM query builder for the repository entity.
+     * @summary Returns a SelectQueryBuilder bound to this repository's entity for advanced querying.
+     * @return {import("typeorm").SelectQueryBuilder<any>} A TypeORM SelectQueryBuilder instance.
+     */
+    queryBuilder() {
+        const repo = this.adapter.dataSource.getRepository(this.class[ModelKeys.ANCHOR]);
+        return repo.createQueryBuilder();
+    }
+    /**
+     * @description Creates and persists a model instance.
+     * @summary Prepares the model, delegates insertion to the adapter, and rehydrates the persisted state back into a Model instance.
+     * @param {M} model The model to create.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M>} The created model instance.
+     */
+    async create(model, ...args) {
+        // eslint-disable-next-line prefer-const
+        let { record, id, transient } = this.adapter.prepare(model, this.pk);
+        record = await this.adapter.create(this.class[ModelKeys.ANCHOR], id, model, ...args);
+        let c = undefined;
+        if (args.length)
+            c = args[args.length - 1];
+        return this.adapter.revert(record, this.class, this.pk, id, c && c.get("rebuildWithTransient") ? transient : undefined);
+    }
+    /**
+     * @description Reads a model from the database by ID.
+     * @summary Retrieves a model instance from the database using its primary key.
+     * @param {string|number|bigint} id - The primary key of the model to read.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The retrieved model instance.
+     */
+    async read(id, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        const m = await this.adapter.read(this.class[ModelKeys.ANCHOR], id, this.pk);
+        return this.adapter.revert(m, this.class, this.pk, id);
+    }
+    /**
+     * @description Updates and persists a model instance.
+     * @summary Prepares the model, delegates update to the adapter, and rehydrates the persisted state back into a Model instance.
+     * @param {M} model The model to update.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M>} The updated model instance.
+     */
+    async update(model, ...args) {
+        // eslint-disable-next-line prefer-const
+        let { record, id, transient } = this.adapter.prepare(model, this.pk);
+        record = await this.adapter.update(this.class[ModelKeys.ANCHOR], id, model, ...args);
+        return this.adapter.revert(record, this.class, this.pk, id, transient);
+    }
+    /**
+     * @description Deletes a model from the database by ID.
+     * @summary Removes a model instance from the database using its primary key.
+     * @param {string|number|bigint} id - The primary key of the model to delete.
+     * @param {...any[]} args - Additional arguments.
+     * @return {Promise<M>} The deleted model instance.
+     */
+    async delete(id, ...args) {
+        const m = await this.adapter.delete(this.class[ModelKeys.ANCHOR], id, this.pk, ...args);
+        return this.adapter.revert(m, this.class, this.pk, id);
+    }
+    /**
+     * @description Validates and prepares models for bulk creation.
+     * @summary Applies decorator-based validations and returns transformed models with context args for createAll.
+     * @param {M[]} models The models to be created.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<[M[], ...any[]]>} The prepared models and forwarded args tuple.
+     */
+    async createAllPrefix(models, ...args) {
+        const contextArgs = await Context.args(OperationKeys.CREATE, this.class, args, this.adapter, this._overrides || {});
+        if (!models.length)
+            return [models, ...contextArgs.args];
+        models = await Promise.all(models.map(async (m) => {
+            m = new this.class(m);
+            await enforceDBDecorators(this, contextArgs.context, m, OperationKeys.CREATE, OperationKeys.ON);
+            return m;
+        }));
+        const errors = models
+            .map((m) => m.hasErrors(...(contextArgs.context.get("ignoredValidationProperties") || [])))
+            .reduce((accum, e, i) => {
+            if (e)
+                accum =
+                    typeof accum === "string"
+                        ? accum + `\n - ${i}: ${e.toString()}`
+                        : ` - ${i}: ${e.toString()}`;
+            return accum;
+        }, undefined);
+        if (errors)
+            throw new ValidationError(errors);
+        return [models, ...contextArgs.args];
+    }
+    /**
+     * @description Creates multiple models at once.
+     * @summary Prepares, persists, and rehydrates a batch of models.
+     * @param {M[]} models The models to create.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M[]>} The created models.
+     */
+    async createAll(models, ...args) {
+        if (!models.length)
+            return models;
+        const prepared = models.map((m) => this.adapter.prepare(m, this.pk));
+        const ids = prepared.map((p) => p.id);
+        let records = prepared.map((p) => p.record);
+        records = await this.adapter.createAll(this.class[ModelKeys.ANCHOR], ids, models, ...args);
+        return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, ids[i]));
+    }
+    /**
+     * @description Reads multiple models by their primary keys.
+     * @summary Retrieves a list of models corresponding to the provided keys.
+     * @param {(string[]|number[])} keys The primary keys to read.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M[]>} The retrieved models.
+     */
+    async readAll(keys, ...args) {
+        const records = await this.adapter.readAll(this.class[ModelKeys.ANCHOR], keys, this.pk, ...args);
+        return records.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
+    }
+    /**
+     * @description Updates multiple models at once.
+     * @summary Persists a batch of model updates and returns their rehydrated instances.
+     * @param {M[]} models The models to update.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M[]>} The updated models.
+     */
+    async updateAll(models, ...args) {
+        const records = models.map((m) => this.adapter.prepare(m, this.pk));
+        const updated = await this.adapter.updateAll(this.class[ModelKeys.ANCHOR], records.map((r) => r.id), models, this.pk, ...args);
+        return updated.map((u, i) => this.adapter.revert(u, this.class, this.pk, records[i].id));
+    }
+    /**
+     * @description Deletes multiple models at once.
+     * @summary Removes a list of models by their primary keys and returns their last persisted states.
+     * @param {(string[]|number[])} keys The primary keys to delete.
+     * @param {...any[]} args Optional arguments/context.
+     * @return {Promise<M[]>} The deleted models.
+     */
+    async deleteAll(keys, ...args) {
+        const results = await this.adapter.deleteAll(this.class[ModelKeys.ANCHOR], keys, this.pk, ...args);
+        return results.map((r, i) => this.adapter.revert(r, this.class, this.pk, keys[i]));
+    }
+};
+TypeORMRepository = __decorate([
+    uses(TypeORMFlavour),
+    __metadata("design:paramtypes", [TypeORMAdapter, Object, Object])
+], TypeORMRepository);
+export { TypeORMRepository };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TypeORMRepository.js","sourceRoot":"","sources":["../../src/TypeORMRepository.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  type Constructor,\n  Model,\n  ModelKeys,\n} from \"@decaf-ts/decorator-validation\";\nimport { Repository, uses } from \"@decaf-ts/core\";\nimport {\n  Context,\n  enforceDBDecorators,\n  OperationKeys,\n  ValidationError,\n} from \"@decaf-ts/db-decorators\";\nimport { TypeORMFlags, TypeORMQuery } from \"./types\";\nimport { TypeORMAdapter } from \"./TypeORMAdapter\";\nimport { TypeORMFlavour } from \"./constants\";\n\n/**\n * @description Repository implementation backed by TypeORM.\n * @summary Provides CRUD operations for a given Model using the {@link TypeORMAdapter}, including bulk operations and query builder access while preserving Decaf.ts repository semantics.\n * @template M Type extending Model that this repository will manage.\n * @param {TypeORMAdapter} adapter The adapter used to execute persistence operations.\n * @param {Constructor<M>} model The Model constructor associated with this repository.\n * @param {...any[]} args Optional arguments forwarded to the base Repository.\n * @class TypeORMRepository\n * @example\n * // Creating a repository\n * const repo = new TypeORMRepository<User>(adapter, User);\n * const created = await repo.create(new User({ name: \"Alice\" }));\n * const read = await repo.read(created.id);\n *\n * // Bulk create\n * await repo.createAll([new User({ name: \"A\" }), new User({ name: \"B\" })]);\n *\n * // Using the query builder\n * const qb = repo.queryBuilder();\n * const rows = await qb.where(\"name = :name\", { name: \"Alice\" }).getMany();\n *\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Repo as TypeORMRepository\n *   participant Adapter as TypeORMAdapter\n *   participant DB as TypeORM/DataSource\n *\n *   App->>Repo: create(model)\n *   Repo->>Adapter: prepare(model, pk)\n *   Adapter-->>Repo: { record, id, transient }\n *   Repo->>Adapter: create(table, id, model, ...args)\n *   Adapter->>DB: INSERT ...\n *   DB-->>Adapter: row\n *   Adapter-->>Repo: row\n *   Repo->>Adapter: revert(row, clazz, pk, id)\n *   Adapter-->>Repo: model\n *   Repo-->>App: model\n */\n@uses(TypeORMFlavour)\nexport class TypeORMRepository<M extends Model> extends Repository<\n  M,\n  TypeORMQuery<M, any>,\n  TypeORMAdapter,\n  TypeORMFlags,\n  Context<TypeORMFlags>\n> {\n  constructor(adapter: TypeORMAdapter, model: Constructor<M>, ...args: any[]) {\n    super(adapter, model, ...args);\n  }\n\n  /**\n   * @description Creates a TypeORM query builder for the repository entity.\n   * @summary Returns a SelectQueryBuilder bound to this repository's entity for advanced querying.\n   * @return {import(\"typeorm\").SelectQueryBuilder<any>} A TypeORM SelectQueryBuilder instance.\n   */\n  queryBuilder() {\n    const repo = this.adapter.dataSource.getRepository(\n      this.class[ModelKeys.ANCHOR as keyof typeof this.class]\n    );\n    return repo.createQueryBuilder();\n  }\n\n  /**\n   * @description Creates and persists a model instance.\n   * @summary Prepares the model, delegates insertion to the adapter, and rehydrates the persisted state back into a Model instance.\n   * @param {M} model The model to create.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M>} The created model instance.\n   */\n  override async create(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.create(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      id,\n      model as any,\n      ...args\n    );\n    let c: Context<TypeORMFlags> | undefined = undefined;\n    if (args.length) c = args[args.length - 1] as Context<TypeORMFlags>;\n    return this.adapter.revert<M>(\n      record,\n      this.class,\n      this.pk,\n      id,\n      c && c.get(\"rebuildWithTransient\") ? transient : undefined\n    );\n  }\n\n  /**\n   * @description Reads a model from the database by ID.\n   * @summary Retrieves a model instance from the database using its primary key.\n   * @param {string|number|bigint} id - The primary key of the model to read.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M>} The retrieved model instance.\n   */\n  override async read(\n    id: string | number | bigint,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<M> {\n    const m = await this.adapter.read(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      id as string,\n      this.pk as string\n    );\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Updates and persists a model instance.\n   * @summary Prepares the model, delegates update to the adapter, and rehydrates the persisted state back into a Model instance.\n   * @param {M} model The model to update.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M>} The updated model instance.\n   */\n  override async update(model: M, ...args: any[]): Promise<M> {\n    // eslint-disable-next-line prefer-const\n    let { record, id, transient } = this.adapter.prepare(model, this.pk);\n    record = await this.adapter.update(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      id,\n      model,\n      ...args\n    );\n    return this.adapter.revert<M>(record, this.class, this.pk, id, transient);\n  }\n\n  /**\n   * @description Deletes a model from the database by ID.\n   * @summary Removes a model instance from the database using its primary key.\n   * @param {string|number|bigint} id - The primary key of the model to delete.\n   * @param {...any[]} args - Additional arguments.\n   * @return {Promise<M>} The deleted model instance.\n   */\n  override async delete(\n    id: string | number | bigint,\n    ...args: any[]\n  ): Promise<M> {\n    const m = await this.adapter.delete(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      id as string,\n      this.pk as string,\n      ...args\n    );\n    return this.adapter.revert<M>(m, this.class, this.pk, id);\n  }\n\n  /**\n   * @description Validates and prepares models for bulk creation.\n   * @summary Applies decorator-based validations and returns transformed models with context args for createAll.\n   * @param {M[]} models The models to be created.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<[M[], ...any[]]>} The prepared models and forwarded args tuple.\n   */\n  protected override async createAllPrefix(models: M[], ...args: any[]) {\n    const contextArgs = await Context.args(\n      OperationKeys.CREATE,\n      this.class,\n      args,\n      this.adapter,\n      this._overrides || {}\n    );\n    if (!models.length) return [models, ...contextArgs.args];\n\n    models = await Promise.all(\n      models.map(async (m) => {\n        m = new this.class(m);\n        await enforceDBDecorators(\n          this,\n          contextArgs.context,\n          m,\n          OperationKeys.CREATE,\n          OperationKeys.ON\n        );\n        return m;\n      })\n    );\n    const errors = models\n      .map((m) =>\n        m.hasErrors(\n          ...(contextArgs.context.get(\"ignoredValidationProperties\") || [])\n        )\n      )\n      .reduce((accum: string | undefined, e, i) => {\n        if (e)\n          accum =\n            typeof accum === \"string\"\n              ? accum + `\\n - ${i}: ${e.toString()}`\n              : ` - ${i}: ${e.toString()}`;\n        return accum;\n      }, undefined);\n    if (errors) throw new ValidationError(errors);\n    return [models, ...contextArgs.args];\n  }\n\n  /**\n   * @description Creates multiple models at once.\n   * @summary Prepares, persists, and rehydrates a batch of models.\n   * @param {M[]} models The models to create.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M[]>} The created models.\n   */\n  override async createAll(models: M[], ...args: any[]): Promise<M[]> {\n    if (!models.length) return models;\n    const prepared = models.map((m) => this.adapter.prepare(m, this.pk));\n    const ids = prepared.map((p) => p.id);\n    let records = prepared.map((p) => p.record);\n    records = await this.adapter.createAll(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      ids as (string | number)[],\n      models,\n      ...args\n    );\n    return records.map((r, i) =>\n      this.adapter.revert(r, this.class, this.pk, ids[i] as string | number)\n    );\n  }\n\n  /**\n   * @description Reads multiple models by their primary keys.\n   * @summary Retrieves a list of models corresponding to the provided keys.\n   * @param {(string[]|number[])} keys The primary keys to read.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M[]>} The retrieved models.\n   */\n  override async readAll(\n    keys: string[] | number[],\n    ...args: any[]\n  ): Promise<M[]> {\n    const records = await this.adapter.readAll(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      keys,\n      this.pk as string,\n      ...args\n    );\n    return records.map((r: Record<string, any>, i: number) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n\n  /**\n   * @description Updates multiple models at once.\n   * @summary Persists a batch of model updates and returns their rehydrated instances.\n   * @param {M[]} models The models to update.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M[]>} The updated models.\n   */\n  override async updateAll(models: M[], ...args: any[]): Promise<M[]> {\n    const records = models.map((m) => this.adapter.prepare(m, this.pk));\n    const updated = await this.adapter.updateAll(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      records.map((r) => r.id),\n      models,\n      this.pk as string,\n      ...args\n    );\n    return updated.map((u: Record<string, any>, i: number) =>\n      this.adapter.revert(u, this.class, this.pk, records[i].id)\n    );\n  }\n\n  /**\n   * @description Deletes multiple models at once.\n   * @summary Removes a list of models by their primary keys and returns their last persisted states.\n   * @param {(string[]|number[])} keys The primary keys to delete.\n   * @param {...any[]} args Optional arguments/context.\n   * @return {Promise<M[]>} The deleted models.\n   */\n  override async deleteAll(\n    keys: string[] | number[],\n    ...args: any[]\n  ): Promise<M[]> {\n    const results = await this.adapter.deleteAll(\n      (this.class as any)[ModelKeys.ANCHOR] as any,\n      keys,\n      this.pk as string,\n      ...args\n    );\n    return results.map((r: Record<string, any>, i: number) =>\n      this.adapter.revert(r, this.class, this.pk, keys[i])\n    );\n  }\n}\n"]}

package/lib/esm/constants.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @description Regular expression to identify reserved attributes for SQL contexts.
+ * @summary Matches attribute names that conflict with SQL reserved keywords to prevent invalid schema or query generation.
+ * @const reservedAttributes
+ * @memberOf module:for-typeorm
+ */
+export declare const reservedAttributes: RegExp;
+export declare const TypeORMFlavour = "type-orm";
+/**
+ * @description Shape of the TypeORMKeys constant.
+ * @summary Describes the keys and their meanings used by the TypeORM adapter.
+ * @typedef TypeORMKeysDef
+ * @property {string} SEPARATOR Separator used to join table and column identifiers.
+ * @property {string} ID Default primary key field name.
+ * @property {string} VERSION Version field used for optimistic locking.
+ * @property {string} DELETED Soft-delete timestamp field.
+ * @property {string} TABLE Database table identifier key.
+ * @property {string} SCHEMA Database schema identifier key.
+ * @property {string} SEQUENCE Database sequence name key.
+ * @property {string} INDEX Index identifier key.
+ * @memberOf module:for-typeorm
+ */
+/**
+ * @description Key constants used by the TypeORM adapter.
+ * @summary Collection of string constants that identify common database properties and adapter-specific keys.
+ * @const TypeORMKeys
+ * @type {TypeORMKeysDef}
+ * @memberOf module:for-typeorm
+ */
+export declare const TypeORMKeys: {
+    SEPARATOR: string;
+    ID: string;
+    VERSION: string;
+    DELETED: string;
+    TABLE: string;
+    SCHEMA: string;
+    SEQUENCE: string;
+    INDEX: string;
+};

package/lib/esm/constants.js

@@ -0,0 +1,40 @@
+/**
+ * @description Regular expression to identify reserved attributes for SQL contexts.
+ * @summary Matches attribute names that conflict with SQL reserved keywords to prevent invalid schema or query generation.
+ * @const reservedAttributes
+ * @memberOf module:for-typeorm
+ */
+export const reservedAttributes = /^(select|from|where|and|or|insert|update|delete|drop|create|table|index|primary|key|foreign|references|constraint|unique|check|default|null|not|as|order|by|group|having|limit|offset|join|inner|outer|left|right|full|on|using|values|returning|set|into|case|when|then|else|end|cast|coalesce|exists|any|all|some|in|between|like|ilike|similar|to|is|true|false|asc|desc|distinct|union|intersect|except|natural|lateral|window|over|partition|range|rows|unbounded|preceding|following|current|row|with|recursive|materialized|view|function|trigger|procedure|language|returns|return|declare|begin|commit|rollback|savepoint|transaction|temporary|temp|if|loop|while|for|continue|exit|raise|exception|notice|info|log|debug|assert|execute|perform|get|diagnostics|call|do|alias|comment|vacuum|analyze|explain|copy|grant|revoke|privileges|public|usage|schema|sequence|owned|owner|tablespace|storage|inherits|type|operator|collate|collation|cascade|restrict|add|alter|column|rename|to|enable|disable|force|no|instead|of|before|after|each|statement|row|execute|also|only|exclude|nulls|others|ordinality|ties|nothing|cache|cycle|increment|minvalue|maxvalue|start|restart|by|called|returns|language|immutable|stable|volatile|strict|security|definer|invoker|cost|rows|support|handler|inline|validator|options|storage|inheritance|oids|without|data|dictionary|encoding|lc_collate|lc_ctype|connection|limit|password|valid|until|superuser|nosuperuser|createdb|nocreatedb|createrole|nocreaterole|inherit|noinherit|login|nologin|replication|noreplication|bypassrls|nobypassrls|encrypted|unencrypted|new|old|session_user|current_user|current_role|current_schema|current_catalog|current_date|current_time|current_timestamp|localtime|localtimestamp|current_database|inet|cidr|macaddr|macaddr8|bit|varbit|tsvector|tsquery|uuid|xml|json|jsonb|int|integer|smallint|bigint|decimal|numeric|real|double|precision|float|boolean|bool|char|character|varchar|text|bytea|date|time|timestamp|interval|point|line|lseg|box|path|polygon|circle|money|void)$/i;
+export const TypeORMFlavour = "type-orm";
+/**
+ * @description Shape of the TypeORMKeys constant.
+ * @summary Describes the keys and their meanings used by the TypeORM adapter.
+ * @typedef TypeORMKeysDef
+ * @property {string} SEPARATOR Separator used to join table and column identifiers.
+ * @property {string} ID Default primary key field name.
+ * @property {string} VERSION Version field used for optimistic locking.
+ * @property {string} DELETED Soft-delete timestamp field.
+ * @property {string} TABLE Database table identifier key.
+ * @property {string} SCHEMA Database schema identifier key.
+ * @property {string} SEQUENCE Database sequence name key.
+ * @property {string} INDEX Index identifier key.
+ * @memberOf module:for-typeorm
+ */
+/**
+ * @description Key constants used by the TypeORM adapter.
+ * @summary Collection of string constants that identify common database properties and adapter-specific keys.
+ * @const TypeORMKeys
+ * @type {TypeORMKeysDef}
+ * @memberOf module:for-typeorm
+ */
+export const TypeORMKeys = {
+    SEPARATOR: ".",
+    ID: "id",
+    VERSION: "version",
+    DELETED: "deleted_at",
+    TABLE: "table_name",
+    SCHEMA: "schema_name",
+    SEQUENCE: "sequence_name",
+    INDEX: "index",
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/errors.d.ts

@@ -0,0 +1,21 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+/**
+ * @description Error thrown when there is an issue with TypeORM indexes.
+ * @summary Represents an error related to index generation or handling within the TypeORM adapter.
+ * @param {string|Error} msg The error message or Error object.
+ * @class
+ * @category Errors
+ * @example
+ * // Example of using IndexError
+ * try {
+ *   // Some code that might throw an index error
+ *   throw new IndexError("Index not found");
+ * } catch (error) {
+ *   if (error instanceof IndexError) {
+ *     console.error("Index error occurred:", error.message);
+ *   }
+ * }
+ */
+export declare class IndexError extends BaseError {
+    constructor(msg: string | Error);
+}

package/lib/esm/errors.js

@@ -0,0 +1,24 @@
+import { BaseError } from "@decaf-ts/db-decorators";
+/**
+ * @description Error thrown when there is an issue with TypeORM indexes.
+ * @summary Represents an error related to index generation or handling within the TypeORM adapter.
+ * @param {string|Error} msg The error message or Error object.
+ * @class
+ * @category Errors
+ * @example
+ * // Example of using IndexError
+ * try {
+ *   // Some code that might throw an index error
+ *   throw new IndexError("Index not found");
+ * } catch (error) {
+ *   if (error instanceof IndexError) {
+ *     console.error("Index error occurred:", error.message);
+ *   }
+ * }
+ */
+export class IndexError extends BaseError {
+    constructor(msg) {
+        super(IndexError.name, msg, 404);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2Vycm9ycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFFcEQ7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDSCxNQUFNLE9BQU8sVUFBVyxTQUFRLFNBQVM7SUFDdkMsWUFBWSxHQUFtQjtRQUM3QixLQUFLLENBQUMsVUFBVSxDQUFDLElBQUksRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDbkMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQmFzZUVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIEVycm9yIHRocm93biB3aGVuIHRoZXJlIGlzIGFuIGlzc3VlIHdpdGggVHlwZU9STSBpbmRleGVzLlxuICogQHN1bW1hcnkgUmVwcmVzZW50cyBhbiBlcnJvciByZWxhdGVkIHRvIGluZGV4IGdlbmVyYXRpb24gb3IgaGFuZGxpbmcgd2l0aGluIHRoZSBUeXBlT1JNIGFkYXB0ZXIuXG4gKiBAcGFyYW0ge3N0cmluZ3xFcnJvcn0gbXNnIFRoZSBlcnJvciBtZXNzYWdlIG9yIEVycm9yIG9iamVjdC5cbiAqIEBjbGFzc1xuICogQGNhdGVnb3J5IEVycm9yc1xuICogQGV4YW1wbGVcbiAqIC8vIEV4YW1wbGUgb2YgdXNpbmcgSW5kZXhFcnJvclxuICogdHJ5IHtcbiAqICAgLy8gU29tZSBjb2RlIHRoYXQgbWlnaHQgdGhyb3cgYW4gaW5kZXggZXJyb3JcbiAqICAgdGhyb3cgbmV3IEluZGV4RXJyb3IoXCJJbmRleCBub3QgZm91bmRcIik7XG4gKiB9IGNhdGNoIChlcnJvcikge1xuICogICBpZiAoZXJyb3IgaW5zdGFuY2VvZiBJbmRleEVycm9yKSB7XG4gKiAgICAgY29uc29sZS5lcnJvcihcIkluZGV4IGVycm9yIG9jY3VycmVkOlwiLCBlcnJvci5tZXNzYWdlKTtcbiAqICAgfVxuICogfVxuICovXG5leHBvcnQgY2xhc3MgSW5kZXhFcnJvciBleHRlbmRzIEJhc2VFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1zZzogc3RyaW5nIHwgRXJyb3IpIHtcbiAgICBzdXBlcihJbmRleEVycm9yLm5hbWUsIG1zZywgNDA0KTtcbiAgfVxufVxuIl19

package/lib/esm/index.d.ts

@@ -0,0 +1,22 @@
+export * from "./indexes";
+export * from "./query";
+export * from "./sequences";
+export * from "./TypeORMAdapter";
+export * from "./constants";
+export * from "./errors";
+export * from "./TypeORMDispatch";
+export * from "./TypeORMRepository";
+export * from "./types";
+export * from "./utils";
+/**
+ * @description TypeORM integration for Decaf.ts.
+ * @summary Provides the TypeORM-backed implementation of the Decaf.ts data access abstractions, including the adapter, repository, statement builder, pagination utilities, index helpers, and type definitions. Key exports include {@link TypeORMAdapter}, {@link TypeORMRepository}, {@link TypeORMStatement}, {@link TypeORMPaginator}, and index generation utilities.
+ * @module for-typeorm
+ */
+/**
+ * @description Stores the current package version.
+ * @summary The version string of the for-typeorm package.
+ * @const VERSION
+ * @memberOf module:for-typeorm
+ */
+export declare const VERSION = "0.0.6";

package/lib/esm/index.js

@@ -0,0 +1,25 @@
+import { TypeORMAdapter } from "./TypeORMAdapter.js";
+TypeORMAdapter.decoration();
+export * from "./indexes/index.js";
+export * from "./query/index.js";
+export * from "./sequences/index.js";
+export * from "./TypeORMAdapter.js";
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./TypeORMDispatch.js";
+export * from "./TypeORMRepository.js";
+export * from "./types.js";
+export * from "./utils.js";
+/**
+ * @description TypeORM integration for Decaf.ts.
+ * @summary Provides the TypeORM-backed implementation of the Decaf.ts data access abstractions, including the adapter, repository, statement builder, pagination utilities, index helpers, and type definitions. Key exports include {@link TypeORMAdapter}, {@link TypeORMRepository}, {@link TypeORMStatement}, {@link TypeORMPaginator}, and index generation utilities.
+ * @module for-typeorm
+ */
+/**
+ * @description Stores the current package version.
+ * @summary The version string of the for-typeorm package.
+ * @const VERSION
+ * @memberOf module:for-typeorm
+ */
+export const VERSION = "0.0.6";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSw0QkFBeUI7QUFFbEQsY0FBYyxDQUFDLFVBQVUsRUFBRSxDQUFDO0FBRTVCLG1DQUEwQjtBQUMxQixpQ0FBd0I7QUFDeEIscUNBQTRCO0FBQzVCLG9DQUFpQztBQUNqQywrQkFBNEI7QUFDNUIsNEJBQXlCO0FBQ3pCLHFDQUFrQztBQUNsQyx1Q0FBb0M7QUFDcEMsMkJBQXdCO0FBQ3hCLDJCQUF3QjtBQUV4Qjs7OztHQUlHO0FBRUg7Ozs7O0dBS0c7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHlwZU9STUFkYXB0ZXIgfSBmcm9tIFwiLi9UeXBlT1JNQWRhcHRlclwiO1xuXG5UeXBlT1JNQWRhcHRlci5kZWNvcmF0aW9uKCk7XG5cbmV4cG9ydCAqIGZyb20gXCIuL2luZGV4ZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3F1ZXJ5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZXF1ZW5jZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1R5cGVPUk1BZGFwdGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vVHlwZU9STURpc3BhdGNoXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9UeXBlT1JNUmVwb3NpdG9yeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIFR5cGVPUk0gaW50ZWdyYXRpb24gZm9yIERlY2FmLnRzLlxuICogQHN1bW1hcnkgUHJvdmlkZXMgdGhlIFR5cGVPUk0tYmFja2VkIGltcGxlbWVudGF0aW9uIG9mIHRoZSBEZWNhZi50cyBkYXRhIGFjY2VzcyBhYnN0cmFjdGlvbnMsIGluY2x1ZGluZyB0aGUgYWRhcHRlciwgcmVwb3NpdG9yeSwgc3RhdGVtZW50IGJ1aWxkZXIsIHBhZ2luYXRpb24gdXRpbGl0aWVzLCBpbmRleCBoZWxwZXJzLCBhbmQgdHlwZSBkZWZpbml0aW9ucy4gS2V5IGV4cG9ydHMgaW5jbHVkZSB7QGxpbmsgVHlwZU9STUFkYXB0ZXJ9LCB7QGxpbmsgVHlwZU9STVJlcG9zaXRvcnl9LCB7QGxpbmsgVHlwZU9STVN0YXRlbWVudH0sIHtAbGluayBUeXBlT1JNUGFnaW5hdG9yfSwgYW5kIGluZGV4IGdlbmVyYXRpb24gdXRpbGl0aWVzLlxuICogQG1vZHVsZSBmb3ItdHlwZW9ybVxuICovXG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIFN0b3JlcyB0aGUgY3VycmVudCBwYWNrYWdlIHZlcnNpb24uXG4gKiBAc3VtbWFyeSBUaGUgdmVyc2lvbiBzdHJpbmcgb2YgdGhlIGZvci10eXBlb3JtIHBhY2thZ2UuXG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItdHlwZW9ybVxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==

package/lib/esm/indexes/generator.d.ts

@@ -0,0 +1,50 @@
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { TypeORMQuery } from "../types";
+/**
+ * @description Generates CouchDB index configurations for models
+ * @summary Creates a set of CouchDB index configurations based on the metadata of the provided models
+ * @template M - The model type that extends Model
+ * @param models - Array of model constructors to generate indexes for
+ * @return {TypeORMQuery} Array of CouchDB index configurations
+ * @function generateIndexes
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant generateIndexes
+ *   participant generateIndexName
+ *   participant Repository
+ *
+ *   Caller->>generateIndexes: models
+ *
+ *   Note over generateIndexes: Create base table index
+ *   generateIndexes->>generateIndexName: [CouchDBKeys.TABLE]
+ *   generateIndexName-->>generateIndexes: tableName
+ *   generateIndexes->>generateIndexes: Create table index config
+ *
+ *   loop For each model
+ *     generateIndexes->>Repository: Get indexes metadata
+ *     Repository-->>generateIndexes: index metadata
+ *
+ *     loop For each index in metadata
+ *       Note over generateIndexes: Extract index properties
+ *       generateIndexes->>Repository: Get table name
+ *       Repository-->>generateIndexes: tableName
+ *
+ *       Note over generateIndexes: Define nested generate function
+ *
+ *       generateIndexes->>generateIndexes: Call generate() for default order
+ *       Note over generateIndexes: Create index name and config
+ *
+ *       alt Has directions
+ *         loop For each direction
+ *           generateIndexes->>generateIndexes: Call generate(direction)
+ *           Note over generateIndexes: Create ordered index config
+ *         end
+ *       end
+ *     end
+ *   end
+ *
+ *   generateIndexes-->>Caller: Array of index configurations
+ */
+export declare function generateIndexes<M extends Model>(models: Constructor<M>[]): TypeORMQuery[];

package/lib/esm/indexes/generator.js

@@ -0,0 +1,95 @@
+import { PersistenceKeys, Repository, } from "@decaf-ts/core";
+import { TypeORMKeys } from "./../constants.js";
+import { DefaultSeparator } from "@decaf-ts/db-decorators";
+/**
+ * @description Generates a name for a CouchDB index
+ * @summary Creates a standardized name for a CouchDB index by combining name parts, compositions, and direction
+ * @param {string[]} name - Array of name parts for the index
+ * @param {OrderDirection} [direction] - Optional sort direction for the index
+ * @param {string[]} [compositions] - Optional additional attributes to include in the index name
+ * @param {string} [separator=DefaultSeparator] - The separator to use between parts of the index name
+ * @return {string} The generated index name
+ * @memberOf module:for-couchdb
+ */
+function generateIndexName(name, direction, compositions, separator = DefaultSeparator) {
+    return [
+        ...name.map((n) => (n === TypeORMKeys.TABLE ? "table" : n)),
+        ...(compositions || []),
+        ...(direction ? [direction] : []),
+        TypeORMKeys.INDEX,
+    ].join(separator);
+}
+/**
+ * @description Generates CouchDB index configurations for models
+ * @summary Creates a set of CouchDB index configurations based on the metadata of the provided models
+ * @template M - The model type that extends Model
+ * @param models - Array of model constructors to generate indexes for
+ * @return {TypeORMQuery} Array of CouchDB index configurations
+ * @function generateIndexes
+ * @memberOf module:for-couchdb
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant generateIndexes
+ *   participant generateIndexName
+ *   participant Repository
+ *
+ *   Caller->>generateIndexes: models
+ *
+ *   Note over generateIndexes: Create base table index
+ *   generateIndexes->>generateIndexName: [CouchDBKeys.TABLE]
+ *   generateIndexName-->>generateIndexes: tableName
+ *   generateIndexes->>generateIndexes: Create table index config
+ *
+ *   loop For each model
+ *     generateIndexes->>Repository: Get indexes metadata
+ *     Repository-->>generateIndexes: index metadata
+ *
+ *     loop For each index in metadata
+ *       Note over generateIndexes: Extract index properties
+ *       generateIndexes->>Repository: Get table name
+ *       Repository-->>generateIndexes: tableName
+ *
+ *       Note over generateIndexes: Define nested generate function
+ *
+ *       generateIndexes->>generateIndexes: Call generate() for default order
+ *       Note over generateIndexes: Create index name and config
+ *
+ *       alt Has directions
+ *         loop For each direction
+ *           generateIndexes->>generateIndexes: Call generate(direction)
+ *           Note over generateIndexes: Create ordered index config
+ *         end
+ *       end
+ *     end
+ *   end
+ *
+ *   generateIndexes-->>Caller: Array of index configurations
+ */
+export function generateIndexes(models) {
+    const tableName = generateIndexName([TypeORMKeys.TABLE]);
+    const indexes = {};
+    indexes[tableName] = {
+        query: ``,
+        values: [],
+    };
+    models.forEach((m) => {
+        const ind = Repository.indexes(m);
+        Object.entries(ind).forEach(([key, value]) => {
+            const k = Object.keys(value)[0];
+            let { compositions } = value[k];
+            const tableName = Repository.table(m);
+            compositions = compositions || [];
+            function generate() {
+                const name = [key, ...compositions, PersistenceKeys.INDEX].join(DefaultSeparator);
+                indexes[name] = {
+                    query: `CREATE INDEX $1 ON $2 ($3);`,
+                    values: [name, tableName, key],
+                };
+            }
+            generate();
+        });
+    });
+    return Object.values(indexes);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/indexes/index.d.ts

@@ -0,0 +1 @@
+export * from "./generator";

package/lib/esm/indexes/index.js

@@ -0,0 +1,2 @@
+export * from "./generator.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW5kZXhlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwrQkFBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9nZW5lcmF0b3JcIjtcbiJdfQ==