@decaf-ts/for-typeorm 0.0.6

package/lib/esm/query/constants.js

@@ -0,0 +1,74 @@
+import { SQLOperator } from "./../types.js";
+/**
+ * @description Default query limit for TypeORM-backed queries.
+ * @summary Maximum number of records to return in a single page when paginating results.
+ * @const TypeORMQueryLimit
+ * @memberOf module:for-typeorm
+ */
+export const TypeORMQueryLimit = 250;
+/**
+ * @description Mapping of operator names to SQL operators.
+ * @summary Constants for comparison operators used when translating high-level filters into SQL via TypeORM.
+ * @typedef {Object} PostgreSQLOperatorType
+ * @property {string} EQUAL Equality operator (=)
+ * @property {string} DIFFERENT Inequality operator (<>)
+ * @property {string} BIGGER Greater than operator (>)
+ * @property {string} BIGGER_EQ Greater than or equal operator (>=)
+ * @property {string} SMALLER Less than operator (<)
+ * @property {string} SMALLER_EQ Less than or equal operator (<=)
+ * @property {string} NOT Negation operator (NOT)
+ * @property {string} IN In array operator (IN)
+ * @property {string} REGEXP Regular expression operator (~)
+ * @property {string} IREGEXP Case-insensitive regular expression operator (~*)
+ * @property {string} LIKE Pattern matching operator (LIKE)
+ * @property {string} ILIKE Case-insensitive pattern matching operator (ILIKE)
+ * @property {string} BETWEEN Range operator (BETWEEN)
+ * @property {string} IS_NULL NULL check operator (IS NULL)
+ * @property {string} IS_NOT_NULL NOT NULL check operator (IS NOT NULL)
+ * @const TypeORMOperator
+ * @type {PostgreSQLOperatorType}
+ * @memberOf module:for-typeorm
+ */
+export const TypeORMOperator = {
+    EQUAL: SQLOperator.EQUAL,
+    DIFFERENT: SQLOperator.NOT_EQUAL,
+    BIGGER: SQLOperator.GREATER_THAN,
+    BIGGER_EQ: SQLOperator.GREATER_THAN_OR_EQUAL,
+    SMALLER: SQLOperator.LESS_THAN,
+    SMALLER_EQ: SQLOperator.LESS_THAN_OR_EQUAL,
+    BETWEEN: SQLOperator.BETWEEN,
+    NOT: "NOT",
+    IN: SQLOperator.IN,
+    IS_NULL: SQLOperator.IS_NULL,
+    IS_NOT_NULL: SQLOperator.IS_NOT_NULL,
+    REGEXP: "~",
+    IREGEXP: "~*",
+    LIKE: SQLOperator.LIKE,
+    ILIKE: SQLOperator.ILIKE,
+};
+/**
+ * @description Mapping of logical operator names to SQL operators.
+ * @summary Constants for logical operators used when building WHERE clause groups in TypeORM queries.
+ * @typedef {Object} PostgreSQLGroupOperatorType
+ * @property {string} AND Logical AND operator (AND)
+ * @property {string} OR Logical OR operator (OR)
+ * @const TypeORMGroupOperator
+ * @type {PostgreSQLGroupOperatorType}
+ * @memberOf module:for-typeorm
+ */
+export const TypeORMGroupOperator = {
+    AND: "AND",
+    OR: "OR",
+};
+/**
+ * @description Special constant values used in queries.
+ * @summary String constants representing special values used while composing SQL with TypeORM.
+ * @typedef {Object} PostgreSQLConstType
+ * @property {string} NULL String representation of null value.
+ * @const TypeORMConst
+ * @memberOf module:for-typeorm
+ */
+export const TypeORMConst = {
+    NULL: "NULL",
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+export * from "./constants";
+export * from "./Paginator";
+export * from "./Statement";
+export * from "./translate";

package/lib/esm/query/index.js

@@ -0,0 +1,5 @@
+export * from "./constants.js";
+export * from "./Paginator.js";
+export * from "./Statement.js";
+export * from "./translate.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcXVlcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0JBQTRCO0FBQzVCLCtCQUE0QjtBQUM1QiwrQkFBNEI7QUFDNUIsK0JBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY29uc3RhbnRzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9QYWdpbmF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1N0YXRlbWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHJhbnNsYXRlXCI7XG4iXX0=

package/lib/esm/query/translate.d.ts

@@ -0,0 +1,34 @@
+import { GroupOperator, Operator } from "@decaf-ts/core";
+import { SQLOperator } from "../types";
+/**
+ * @description Translates core operators to TypeORM SQL operators.
+ * @summary Converts Decaf.ts core operators to their equivalent SQL operators used by the TypeORM adapter.
+ * @param {GroupOperator | Operator} operator The core operator to translate.
+ * @return {SQLOperator | string} The equivalent SQL operator.
+ * @throws {QueryError} If no translation exists for the given operator.
+ * @function translateOperators
+ * @memberOf module:for-typeorm
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant translateOperators
+ *   participant PostgreSQLOperator
+ *   participant PostgreSQLGroupOperator
+ *
+ *   Caller->>translateOperators: operator
+ *
+ *   translateOperators->>PostgreSQLOperator: Check for match
+ *   alt Found in PostgreSQLOperator
+ *     PostgreSQLOperator-->>translateOperators: Return matching operator
+ *     translateOperators-->>Caller: Return SQLOperator
+ *   else Not found
+ *     translateOperators->>PostgreSQLGroupOperator: Check for match
+ *     alt Found in PostgreSQLGroupOperator
+ *       PostgreSQLGroupOperator-->>translateOperators: Return matching operator
+ *       translateOperators-->>Caller: Return string
+ *     else Not found
+ *       translateOperators-->>Caller: Throw QueryError
+ *     end
+ *   end
+ */
+export declare function translateOperators(operator: GroupOperator | Operator): SQLOperator | string;

package/lib/esm/query/translate.js

@@ -0,0 +1,42 @@
+import { TypeORMGroupOperator, TypeORMOperator } from "./constants.js";
+import { QueryError } from "@decaf-ts/core";
+/**
+ * @description Translates core operators to TypeORM SQL operators.
+ * @summary Converts Decaf.ts core operators to their equivalent SQL operators used by the TypeORM adapter.
+ * @param {GroupOperator | Operator} operator The core operator to translate.
+ * @return {SQLOperator | string} The equivalent SQL operator.
+ * @throws {QueryError} If no translation exists for the given operator.
+ * @function translateOperators
+ * @memberOf module:for-typeorm
+ * @mermaid
+ * sequenceDiagram
+ *   participant Caller
+ *   participant translateOperators
+ *   participant PostgreSQLOperator
+ *   participant PostgreSQLGroupOperator
+ *
+ *   Caller->>translateOperators: operator
+ *
+ *   translateOperators->>PostgreSQLOperator: Check for match
+ *   alt Found in PostgreSQLOperator
+ *     PostgreSQLOperator-->>translateOperators: Return matching operator
+ *     translateOperators-->>Caller: Return SQLOperator
+ *   else Not found
+ *     translateOperators->>PostgreSQLGroupOperator: Check for match
+ *     alt Found in PostgreSQLGroupOperator
+ *       PostgreSQLGroupOperator-->>translateOperators: Return matching operator
+ *       translateOperators-->>Caller: Return string
+ *     else Not found
+ *       translateOperators-->>Caller: Throw QueryError
+ *     end
+ *   end
+ */
+export function translateOperators(operator) {
+    for (const operators of [TypeORMOperator, TypeORMGroupOperator]) {
+        const el = Object.keys(operators).find((k) => k === operator);
+        if (el)
+            return operators[el];
+    }
+    throw new QueryError(`Could not find adapter translation for operator ${operator}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/raw/postgres.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @description Definition of a PostgreSQL result field.
+ * @summary Describes metadata for a column returned in a PostgreSQL query result, including identifiers and type information.
+ * @interface FieldDef
+ * @memberOf module:for-typeorm
+ */
+export interface FieldDef {
+    name: string;
+    tableID: number;
+    columnID: number;
+    dataTypeID: number;
+    dataTypeSize: number;
+    dataTypeModifier: number;
+    format: string;
+}
+/**
+ * @description Base shape for PostgreSQL query results.
+ * @summary Contains common properties present in all PostgreSQL query results such as the executed command, row count, oid, and fields metadata.
+ * @interface QueryResultBase
+ * @memberOf module:for-typeorm
+ */
+export interface QueryResultBase {
+    command: string;
+    rowCount: number | null;
+    oid: number;
+    fields: FieldDef[];
+}
+export interface QueryResultRow {
+    [column: string]: any;
+}
+export interface QueryResult<R extends QueryResultRow = any> extends QueryResultBase {
+    rows: R[];
+}
+export interface QueryArrayResult<R extends any[] = any[]> extends QueryResultBase {
+    rows: R[];
+}

package/lib/esm/raw/postgres.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9zdGdyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmF3L3Bvc3RncmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBEZWZpbml0aW9uIG9mIGEgUG9zdGdyZVNRTCByZXN1bHQgZmllbGQuXG4gKiBAc3VtbWFyeSBEZXNjcmliZXMgbWV0YWRhdGEgZm9yIGEgY29sdW1uIHJldHVybmVkIGluIGEgUG9zdGdyZVNRTCBxdWVyeSByZXN1bHQsIGluY2x1ZGluZyBpZGVudGlmaWVycyBhbmQgdHlwZSBpbmZvcm1hdGlvbi5cbiAqIEBpbnRlcmZhY2UgRmllbGREZWZcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Zm9yLXR5cGVvcm1cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBGaWVsZERlZiB7XG4gIG5hbWU6IHN0cmluZztcbiAgdGFibGVJRDogbnVtYmVyO1xuICBjb2x1bW5JRDogbnVtYmVyO1xuICBkYXRhVHlwZUlEOiBudW1iZXI7XG4gIGRhdGFUeXBlU2l6ZTogbnVtYmVyO1xuICBkYXRhVHlwZU1vZGlmaWVyOiBudW1iZXI7XG4gIGZvcm1hdDogc3RyaW5nO1xufVxuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBCYXNlIHNoYXBlIGZvciBQb3N0Z3JlU1FMIHF1ZXJ5IHJlc3VsdHMuXG4gKiBAc3VtbWFyeSBDb250YWlucyBjb21tb24gcHJvcGVydGllcyBwcmVzZW50IGluIGFsbCBQb3N0Z3JlU1FMIHF1ZXJ5IHJlc3VsdHMgc3VjaCBhcyB0aGUgZXhlY3V0ZWQgY29tbWFuZCwgcm93IGNvdW50LCBvaWQsIGFuZCBmaWVsZHMgbWV0YWRhdGEuXG4gKiBAaW50ZXJmYWNlIFF1ZXJ5UmVzdWx0QmFzZVxuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItdHlwZW9ybVxuICovXG5leHBvcnQgaW50ZXJmYWNlIFF1ZXJ5UmVzdWx0QmFzZSB7XG4gIGNvbW1hbmQ6IHN0cmluZztcbiAgcm93Q291bnQ6IG51bWJlciB8IG51bGw7XG4gIG9pZDogbnVtYmVyO1xuICBmaWVsZHM6IEZpZWxkRGVmW107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUXVlcnlSZXN1bHRSb3cge1xuICBbY29sdW1uOiBzdHJpbmddOiBhbnk7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUXVlcnlSZXN1bHQ8UiBleHRlbmRzIFF1ZXJ5UmVzdWx0Um93ID0gYW55PlxuICBleHRlbmRzIFF1ZXJ5UmVzdWx0QmFzZSB7XG4gIHJvd3M6IFJbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBRdWVyeUFycmF5UmVzdWx0PFIgZXh0ZW5kcyBhbnlbXSA9IGFueVtdPlxuICBleHRlbmRzIFF1ZXJ5UmVzdWx0QmFzZSB7XG4gIHJvd3M6IFJbXTtcbn1cbiJdfQ==

package/lib/esm/sequences/Sequence.d.ts

@@ -0,0 +1,67 @@
+import { SequenceOptions } from "@decaf-ts/core";
+import { Sequence } from "@decaf-ts/core";
+import { TypeORMAdapter } from "../TypeORMAdapter";
+/**
+ * @description Abstract implementation of a database sequence for TypeORM.
+ * @summary Provides the basic functionality for {@link Sequence}s, delegating to the {@link TypeORMAdapter} to fetch and increment values while handling type parsing and error translation.
+ * @param {SequenceOptions} options The sequence configuration options (name, type, startWith, incrementBy, etc.).
+ * @param {TypeORMAdapter} adapter The TypeORM adapter used to execute sequence operations.
+ * @class TypeORMSequence
+ * @implements Sequence
+ * @example
+ * // Create and use a TypeORM-backed sequence
+ * const seq = new TypeORMSequence({ name: "user_id_seq", type: "Number", startWith: 1, incrementBy: 1 }, adapter);
+ * const nextId = await seq.next();
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Seq as TypeORMSequence
+ *   participant Adapter as TypeORMAdapter
+ *   participant DB as Database
+ *   App->>Seq: next()
+ *   Seq->>Seq: current()
+ *   Seq->>Adapter: raw(SELECT current_value ...)
+ *   Adapter->>DB: Query current value
+ *   DB-->>Adapter: current_value
+ *   Adapter-->>Seq: value
+ *   Seq->>Seq: increment(current)
+ *   Seq->>Adapter: raw(nextval(name))
+ *   Adapter->>DB: nextval()
+ *   DB-->>Adapter: next value
+ *   Adapter-->>Seq: value
+ *   Seq-->>App: parsed next value
+ */
+export declare class TypeORMSequence extends Sequence {
+    protected adapter: TypeORMAdapter;
+    constructor(options: SequenceOptions, adapter: TypeORMAdapter);
+    /**
+     * @summary Retrieves the current value for the sequence
+     * @protected
+     */
+    current(): Promise<string | number | bigint>;
+    /**
+     * @summary Parses the {@link Sequence} value
+     *
+     * @protected
+     * @param value
+     */
+    private parse;
+    /**
+     * @summary increments the sequence
+     * @description Sequence specific implementation
+     *
+     * @param {string | number | bigint} current
+     * @param count
+     * @protected
+     */
+    private increment;
+    /**
+     * @summary Generates the next value in th sequence
+     * @description calls {@link Sequence#parse} on the current value
+     * followed by {@link Sequence#increment}
+     *
+     */
+    next(): Promise<number | string | bigint>;
+    range(count: number): Promise<(number | string | bigint)[]>;
+}

package/lib/esm/sequences/Sequence.js

@@ -0,0 +1,117 @@
+import { InternalError, NotFoundError } from "@decaf-ts/db-decorators";
+import { Sequence } from "@decaf-ts/core";
+/**
+ * @description Abstract implementation of a database sequence for TypeORM.
+ * @summary Provides the basic functionality for {@link Sequence}s, delegating to the {@link TypeORMAdapter} to fetch and increment values while handling type parsing and error translation.
+ * @param {SequenceOptions} options The sequence configuration options (name, type, startWith, incrementBy, etc.).
+ * @param {TypeORMAdapter} adapter The TypeORM adapter used to execute sequence operations.
+ * @class TypeORMSequence
+ * @implements Sequence
+ * @example
+ * // Create and use a TypeORM-backed sequence
+ * const seq = new TypeORMSequence({ name: "user_id_seq", type: "Number", startWith: 1, incrementBy: 1 }, adapter);
+ * const nextId = await seq.next();
+ *
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Seq as TypeORMSequence
+ *   participant Adapter as TypeORMAdapter
+ *   participant DB as Database
+ *   App->>Seq: next()
+ *   Seq->>Seq: current()
+ *   Seq->>Adapter: raw(SELECT current_value ...)
+ *   Adapter->>DB: Query current value
+ *   DB-->>Adapter: current_value
+ *   Adapter-->>Seq: value
+ *   Seq->>Seq: increment(current)
+ *   Seq->>Adapter: raw(nextval(name))
+ *   Adapter->>DB: nextval()
+ *   DB-->>Adapter: next value
+ *   Adapter-->>Seq: value
+ *   Seq-->>App: parsed next value
+ */
+export class TypeORMSequence extends Sequence {
+    constructor(options, adapter) {
+        super(options);
+        this.adapter = adapter;
+    }
+    /**
+     * @summary Retrieves the current value for the sequence
+     * @protected
+     */
+    async current() {
+        const { name } = this.options;
+        try {
+            const seq = await this.adapter.raw({
+                query: `SELECT current_value FROM information_schema.sequences WHERE sequence_name = $1`,
+                values: [name],
+            });
+            return this.parse(seq.current_value);
+        }
+        catch (e) {
+            throw this.adapter.parseError(e);
+        }
+    }
+    /**
+     * @summary Parses the {@link Sequence} value
+     *
+     * @protected
+     * @param value
+     */
+    parse(value) {
+        return Sequence.parseValue(this.options.type, value);
+    }
+    /**
+     * @summary increments the sequence
+     * @description Sequence specific implementation
+     *
+     * @param {string | number | bigint} current
+     * @param count
+     * @protected
+     */
+    async increment(current, count) {
+        const { type, incrementBy, name, startWith } = this.options;
+        if (type !== "Number" && type !== "BigInt")
+            throw new InternalError(`Cannot increment sequence of type ${type} with ${count}`);
+        let next;
+        try {
+            next = await this.adapter.raw({
+                query: `SELECT nextval($1);`,
+                values: [name],
+            });
+        }
+        catch (e) {
+            if (!(e instanceof NotFoundError))
+                throw e;
+            next = await this.adapter.raw({
+                query: `CREATE SEQUENCE IF NOT EXISTS $1 START WITH $2 INCREMENT BY $3 NO CYCLE;`,
+                values: [name, startWith, incrementBy],
+            });
+        }
+        return next;
+    }
+    /**
+     * @summary Generates the next value in th sequence
+     * @description calls {@link Sequence#parse} on the current value
+     * followed by {@link Sequence#increment}
+     *
+     */
+    async next() {
+        const current = await this.current();
+        return this.increment(current);
+    }
+    async range(count) {
+        const current = (await this.current());
+        const incrementBy = this.parse(this.options.incrementBy);
+        const next = await this.increment(current, this.parse(count) * incrementBy);
+        const range = [];
+        for (let i = 1; i <= count; i++) {
+            range.push(current + incrementBy * this.parse(i));
+        }
+        if (range[range.length - 1] !== next)
+            throw new InternalError("Miscalculation of range");
+        return range;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Sequence.js","sourceRoot":"","sources":["../../../src/sequences/Sequence.ts"],"names":[],"mappings":"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","sourcesContent":["import { InternalError, NotFoundError } from \"@decaf-ts/db-decorators\";\nimport { SequenceOptions } from \"@decaf-ts/core\";\nimport { Sequence } from \"@decaf-ts/core\";\nimport { TypeORMAdapter } from \"../TypeORMAdapter\";\n\n/**\n * @description Abstract implementation of a database sequence for TypeORM.\n * @summary Provides the basic functionality for {@link Sequence}s, delegating to the {@link TypeORMAdapter} to fetch and increment values while handling type parsing and error translation.\n * @param {SequenceOptions} options The sequence configuration options (name, type, startWith, incrementBy, etc.).\n * @param {TypeORMAdapter} adapter The TypeORM adapter used to execute sequence operations.\n * @class TypeORMSequence\n * @implements Sequence\n * @example\n * // Create and use a TypeORM-backed sequence\n * const seq = new TypeORMSequence({ name: \"user_id_seq\", type: \"Number\", startWith: 1, incrementBy: 1 }, adapter);\n * const nextId = await seq.next();\n *\n * @mermaid\n * sequenceDiagram\n *   participant App\n *   participant Seq as TypeORMSequence\n *   participant Adapter as TypeORMAdapter\n *   participant DB as Database\n *   App->>Seq: next()\n *   Seq->>Seq: current()\n *   Seq->>Adapter: raw(SELECT current_value ...)\n *   Adapter->>DB: Query current value\n *   DB-->>Adapter: current_value\n *   Adapter-->>Seq: value\n *   Seq->>Seq: increment(current)\n *   Seq->>Adapter: raw(nextval(name))\n *   Adapter->>DB: nextval()\n *   DB-->>Adapter: next value\n *   Adapter-->>Seq: value\n *   Seq-->>App: parsed next value\n */\nexport class TypeORMSequence extends Sequence {\n  constructor(\n    options: SequenceOptions,\n    protected adapter: TypeORMAdapter\n  ) {\n    super(options);\n  }\n\n  /**\n   * @summary Retrieves the current value for the sequence\n   * @protected\n   */\n  async current(): Promise<string | number | bigint> {\n    const { name } = this.options;\n    try {\n      const seq: any = await this.adapter.raw({\n        query: `SELECT current_value FROM information_schema.sequences WHERE sequence_name = $1`,\n        values: [name],\n      });\n      return this.parse(seq.current_value as string | number);\n    } catch (e: unknown) {\n      throw this.adapter.parseError(e as Error);\n    }\n  }\n\n  /**\n   * @summary Parses the {@link Sequence} value\n   *\n   * @protected\n   * @param value\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return Sequence.parseValue(this.options.type, value);\n  }\n\n  /**\n   * @summary increments the sequence\n   * @description Sequence specific implementation\n   *\n   * @param {string | number | bigint} current\n   * @param count\n   * @protected\n   */\n  private async increment(\n    current: string | number | bigint,\n    count?: number\n  ): Promise<string | number | bigint> {\n    const { type, incrementBy, name, startWith } = this.options;\n    if (type !== \"Number\" && type !== \"BigInt\")\n      throw new InternalError(\n        `Cannot increment sequence of type ${type} with ${count}`\n      );\n    let next: string | number | bigint;\n    try {\n      next = await this.adapter.raw({\n        query: `SELECT nextval($1);`,\n        values: [name],\n      });\n    } catch (e: unknown) {\n      if (!(e instanceof NotFoundError)) throw e;\n      next = await this.adapter.raw({\n        query: `CREATE SEQUENCE IF NOT EXISTS $1 START WITH $2 INCREMENT BY $3 NO CYCLE;`,\n        values: [name, startWith, incrementBy],\n      });\n    }\n\n    return next as string | number | bigint;\n  }\n\n  /**\n   * @summary Generates the next value in th sequence\n   * @description calls {@link Sequence#parse} on the current value\n   * followed by {@link Sequence#increment}\n   *\n   */\n  async next(): Promise<number | string | bigint> {\n    const current = await this.current();\n    return this.increment(current);\n  }\n\n  async range(count: number): Promise<(number | string | bigint)[]> {\n    const current = (await this.current()) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n"]}

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

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

package/lib/esm/sequences/index.js

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

package/lib/esm/types.d.ts

@@ -0,0 +1,67 @@
+import { RepositoryFlags } from "@decaf-ts/db-decorators";
+import { SelectQueryBuilder } from "typeorm";
+import { Model } from "@decaf-ts/decorator-validation";
+/**
+ * @description SQL operators available for building TypeORM queries.
+ * @summary Enumeration of common SQL operators intended for use within TypeORM query construction and translation layers.
+ * @enum {string}
+ * @memberOf module:for-typeorm
+ */
+export declare enum SQLOperator {
+    EQUAL = "=",
+    NOT_EQUAL = "<>",
+    LESS_THAN = "<",
+    LESS_THAN_OR_EQUAL = "<=",
+    GREATER_THAN = ">",
+    GREATER_THAN_OR_EQUAL = ">=",
+    IN = "IN",
+    NOT_IN = "NOT IN",
+    LIKE = "LIKE",
+    ILIKE = "ILIKE",
+    BETWEEN = "BETWEEN",
+    IS_NULL = "IS NULL",
+    IS_NOT_NULL = "IS NOT NULL",
+    EXISTS = "EXISTS",
+    NOT_EXISTS = "NOT EXISTS",
+    ANY = "ANY",
+    ALL = "ALL",
+    SOME = "SOME"
+}
+/**
+ * @description Query container used by the TypeORM adapter.
+ * @summary Represents either a raw SQL string or a TypeORM SelectQueryBuilder along with optional bound values to be executed by the adapter.
+ * @template M The Model type for which the SelectQueryBuilder is parameterized.
+ * @template T The underlying query type, either a string or a SelectQueryBuilder<M>.
+ * @interface TypeORMQuery
+ * @memberOf module:for-typeorm
+ */
+export interface TypeORMQuery<M extends Model = Model, T extends string | SelectQueryBuilder<M> = string> {
+    query: T;
+    values?: any[];
+}
+/**
+ * @description Configuration flags for TypeORM operations.
+ * @summary Extended repository flags including connection/user context that can be leveraged by the TypeORM adapter.
+ * @interface TypeORMFlags
+ * @memberOf module:for-typeorm
+ */
+export interface TypeORMFlags extends RepositoryFlags {
+    /**
+     * @description User authentication information for Postgres database connections
+     */
+    user: string;
+}
+/**
+ * @description Specification for a table creation/change statement used by the TypeORM adapter.
+ * @summary Extends a TypeORMQuery with table metadata such as primary key flag, constraints, and foreign keys.
+ * @typedef TypeORMTableSpec
+ * @property {boolean} primaryKey Indicates if the target column is part of the primary key.
+ * @property {string[]} constraints A list of raw SQL constraints to apply to the table/column.
+ * @property {string[]} foreignKeys A list of foreign key constraint definitions.
+ * @memberOf module:for-typeorm
+ */
+export type TypeORMTableSpec = TypeORMQuery & {
+    primaryKey: boolean;
+    constraints: string[];
+    foreignKeys: string[];
+};

package/lib/esm/types.js

@@ -0,0 +1,28 @@
+/**
+ * @description SQL operators available for building TypeORM queries.
+ * @summary Enumeration of common SQL operators intended for use within TypeORM query construction and translation layers.
+ * @enum {string}
+ * @memberOf module:for-typeorm
+ */
+export var SQLOperator;
+(function (SQLOperator) {
+    SQLOperator["EQUAL"] = "=";
+    SQLOperator["NOT_EQUAL"] = "<>";
+    SQLOperator["LESS_THAN"] = "<";
+    SQLOperator["LESS_THAN_OR_EQUAL"] = "<=";
+    SQLOperator["GREATER_THAN"] = ">";
+    SQLOperator["GREATER_THAN_OR_EQUAL"] = ">=";
+    SQLOperator["IN"] = "IN";
+    SQLOperator["NOT_IN"] = "NOT IN";
+    SQLOperator["LIKE"] = "LIKE";
+    SQLOperator["ILIKE"] = "ILIKE";
+    SQLOperator["BETWEEN"] = "BETWEEN";
+    SQLOperator["IS_NULL"] = "IS NULL";
+    SQLOperator["IS_NOT_NULL"] = "IS NOT NULL";
+    SQLOperator["EXISTS"] = "EXISTS";
+    SQLOperator["NOT_EXISTS"] = "NOT EXISTS";
+    SQLOperator["ANY"] = "ANY";
+    SQLOperator["ALL"] = "ALL";
+    SQLOperator["SOME"] = "SOME";
+})(SQLOperator || (SQLOperator = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/utils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @description Converts a JavaScript RegExp pattern to a PostgreSQL POSIX pattern string.
+ * @summary Accepts either a RegExp object or a string representation (/pattern/flags) and returns the raw pattern compatible with PostgreSQL's ~ and ~* operators.
+ * @param {RegExp|string} jsRegex JavaScript RegExp object or pattern string.
+ * @return {string} PostgreSQL-compatible regex pattern string.
+ * @function convertJsRegexToPostgres
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Utils as convertJsRegexToPostgres
+ *   App->>Utils: convertJsRegexToPostgres(RegExp("foo.*","i"))
+ *   Utils->>Utils: Parse string or use RegExp.source
+ *   Utils-->>App: "foo.*"
+ * @memberOf module:for-typeorm
+ */
+export declare function convertJsRegexToPostgres(jsRegex: RegExp | string): string;

package/lib/esm/utils.js

@@ -0,0 +1,29 @@
+/**
+ * @description Converts a JavaScript RegExp pattern to a PostgreSQL POSIX pattern string.
+ * @summary Accepts either a RegExp object or a string representation (/pattern/flags) and returns the raw pattern compatible with PostgreSQL's ~ and ~* operators.
+ * @param {RegExp|string} jsRegex JavaScript RegExp object or pattern string.
+ * @return {string} PostgreSQL-compatible regex pattern string.
+ * @function convertJsRegexToPostgres
+ * @mermaid
+ * sequenceDiagram
+ *   participant App
+ *   participant Utils as convertJsRegexToPostgres
+ *   App->>Utils: convertJsRegexToPostgres(RegExp("foo.*","i"))
+ *   Utils->>Utils: Parse string or use RegExp.source
+ *   Utils-->>App: "foo.*"
+ * @memberOf module:for-typeorm
+ */
+export function convertJsRegexToPostgres(jsRegex) {
+    const rxp = new RegExp(/^\/(.+)\/(\w+)$/g);
+    if (typeof jsRegex === "string") {
+        const match = rxp.exec(jsRegex);
+        if (match) {
+            const [, p] = match;
+            jsRegex = p;
+        }
+    }
+    const regex = typeof jsRegex === "string" ? new RegExp(jsRegex) : jsRegex;
+    const pattern = regex.source;
+    return pattern;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.cjs

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+const TypeORMAdapter_1 = require("./TypeORMAdapter.cjs");
+TypeORMAdapter_1.TypeORMAdapter.decoration();
+__exportStar(require("./indexes/index.cjs"), exports);
+__exportStar(require("./query/index.cjs"), exports);
+__exportStar(require("./sequences/index.cjs"), exports);
+__exportStar(require("./TypeORMAdapter.cjs"), exports);
+__exportStar(require("./constants.cjs"), exports);
+__exportStar(require("./errors.cjs"), exports);
+__exportStar(require("./TypeORMDispatch.cjs"), exports);
+__exportStar(require("./TypeORMRepository.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+__exportStar(require("./utils.cjs"), exports);
+/**
+ * @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
+ */
+exports.VERSION = "0.0.6";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx5REFBa0Q7QUFFbEQsK0JBQWMsQ0FBQyxVQUFVLEVBQUUsQ0FBQztBQUU1QixzREFBMEI7QUFDMUIsb0RBQXdCO0FBQ3hCLHdEQUE0QjtBQUM1Qix1REFBaUM7QUFDakMsa0RBQTRCO0FBQzVCLCtDQUF5QjtBQUN6Qix3REFBa0M7QUFDbEMsMERBQW9DO0FBQ3BDLDhDQUF3QjtBQUN4Qiw4Q0FBd0I7QUFFeEI7Ozs7R0FJRztBQUVIOzs7OztHQUtHO0FBQ1UsUUFBQSxPQUFPLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHlwZU9STUFkYXB0ZXIgfSBmcm9tIFwiLi9UeXBlT1JNQWRhcHRlclwiO1xuXG5UeXBlT1JNQWRhcHRlci5kZWNvcmF0aW9uKCk7XG5cbmV4cG9ydCAqIGZyb20gXCIuL2luZGV4ZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3F1ZXJ5XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zZXF1ZW5jZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1R5cGVPUk1BZGFwdGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2Vycm9yc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vVHlwZU9STURpc3BhdGNoXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9UeXBlT1JNUmVwb3NpdG9yeVwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIFR5cGVPUk0gaW50ZWdyYXRpb24gZm9yIERlY2FmLnRzLlxuICogQHN1bW1hcnkgUHJvdmlkZXMgdGhlIFR5cGVPUk0tYmFja2VkIGltcGxlbWVudGF0aW9uIG9mIHRoZSBEZWNhZi50cyBkYXRhIGFjY2VzcyBhYnN0cmFjdGlvbnMsIGluY2x1ZGluZyB0aGUgYWRhcHRlciwgcmVwb3NpdG9yeSwgc3RhdGVtZW50IGJ1aWxkZXIsIHBhZ2luYXRpb24gdXRpbGl0aWVzLCBpbmRleCBoZWxwZXJzLCBhbmQgdHlwZSBkZWZpbml0aW9ucy4gS2V5IGV4cG9ydHMgaW5jbHVkZSB7QGxpbmsgVHlwZU9STUFkYXB0ZXJ9LCB7QGxpbmsgVHlwZU9STVJlcG9zaXRvcnl9LCB7QGxpbmsgVHlwZU9STVN0YXRlbWVudH0sIHtAbGluayBUeXBlT1JNUGFnaW5hdG9yfSwgYW5kIGluZGV4IGdlbmVyYXRpb24gdXRpbGl0aWVzLlxuICogQG1vZHVsZSBmb3ItdHlwZW9ybVxuICovXG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIFN0b3JlcyB0aGUgY3VycmVudCBwYWNrYWdlIHZlcnNpb24uXG4gKiBAc3VtbWFyeSBUaGUgdmVyc2lvbiBzdHJpbmcgb2YgdGhlIGZvci10eXBlb3JtIHBhY2thZ2UuXG4gKiBAY29uc3QgVkVSU0lPTlxuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItdHlwZW9ybVxuICovXG5leHBvcnQgY29uc3QgVkVSU0lPTiA9IFwiIyNWRVJTSU9OIyNcIjtcbiJdfQ==