@decaf-ts/for-typeorm 0.0.6

package/lib/query/Statement.d.ts

@@ -0,0 +1,131 @@
+import { Condition, GroupOperator, Operator, Paginator, Statement } from "@decaf-ts/core";
+import { Model } from "@decaf-ts/decorator-validation";
+import { TypeORMQuery } from "../types";
+import { TypeORMAdapter } from "../TypeORMAdapter";
+import { SelectQueryBuilder } from "typeorm";
+import { FindOptionsWhere } from "typeorm/find-options/FindOptionsWhere";
+/**
+ * @description Statement builder for TypeORM-backed queries.
+ * @summary Provides a fluent interface for building SQL queries via TypeORM's SelectQueryBuilder with type safety and Decaf.ts abstractions.
+ * @template M The model type that extends Model.
+ * @template R The result type returned from execution.
+ * @param {TypeORMAdapter} adapter The TypeORM adapter.
+ * @class TypeORMStatement
+ * @example
+ * // Example using TypeORMStatement
+ * const statement = new TypeORMStatement<User, User[]>(adapter);
+ * const users = await statement
+ *   .from(User)
+ *   .where(Condition.attribute<User>('age').gt(18))
+ *   .orderBy('lastName', 'asc')
+ *   .limit(10)
+ *   .execute();
+ */
+export declare class TypeORMStatement<M extends Model, R> extends Statement<TypeORMQuery<M>, M, R> {
+    protected adapter: TypeORMAdapter;
+    constructor(adapter: TypeORMAdapter);
+    /**
+     * @description Builds a TypeORM SelectQueryBuilder from the statement.
+     * @summary Converts the statement's conditions, selectors, and options into a TypeORM-backed query object.
+     * @return {TypeORMQuery} The built TypeORM query container.
+     * @throws {Error} If there are invalid query conditions.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant Repository
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: build()
+     *   Note over Statement: Initialize query
+     *   Statement->>Repository: Get table name
+     *   Repository-->>Statement: Return table name
+     *   Statement->>Statement: Create base query
+     *
+     *   alt Has selectSelector
+     *     Statement->>Statement: Add columns to query
+     *   end
+     *
+     *   alt Has whereCondition
+     *     Statement->>Statement: Create combined condition with table
+     *     Statement->>parseCondition: Parse condition
+     *     parseCondition-->>Statement: Return parsed conditions
+     *     Statement->>Statement: Add conditions to query
+     *   end
+     *
+     *   alt Has orderBySelector
+     *     Statement->>Statement: Add orderBy to query
+     *   end
+     *
+     *   alt Has limitSelector
+     *     Statement->>Statement: Set limit
+     *   else
+     *     Statement->>Statement: Use default limit
+     *   end
+     *
+     *   alt Has offsetSelector
+     *     Statement->>Statement: Set offset
+     *   end
+     *
+     *   Statement-->>Statement: Return query
+     */
+    protected build(): TypeORMQuery<M>;
+    /**
+     * @description Creates a paginator for the statement.
+     * @summary Builds the query and returns a TypeORMPaginator for paginated results.
+     * @template R The result type.
+     * @param {number} size The page size.
+     * @return {Promise<Paginator<M, R, TypeORMQuery>>} A promise that resolves to a paginator.
+     * @throws {InternalError} If there's an error building the query.
+     */
+    paginate<R>(size: number): Promise<Paginator<M, R, TypeORMQuery>>;
+    /**
+     * @description Processes a record.
+     * @summary Converts a raw result row to a model instance using the adapter.
+     * @param {any} r The raw record.
+     * @param {keyof M} pkAttr The primary key attribute of the model.
+     * @param {"Number" | "BigInt" | undefined} sequenceType The type of the sequence.
+     * @return {any} The processed record.
+     */
+    private processRecord;
+    /**
+     * @description Executes a raw TypeORM query builder.
+     * @summary Sends the built SelectQueryBuilder to the database via TypeORM and returns the results.
+     * @template R The result type.
+     * @param {TypeORMQuery} rawInput The query container to execute.
+     * @return {Promise<R>} A promise that resolves to the query results.
+     */
+    raw<R>(rawInput: TypeORMQuery<M>): Promise<R>;
+    protected parseConditionForPagination(condition: Condition<M>, tableName: string, counter?: number, conditionalOp?: GroupOperator | Operator): FindOptionsWhere<M>[] | FindOptionsWhere<M>;
+    /**
+     * @description Parses a condition into PostgreSQL conditions
+     * @summary Converts a Condition object into PostgreSQL condition structures
+     * @param {Condition<M>} condition - The condition to parse
+     * @param {string} [tableName] - the positional index of the arguments
+     * @return {TypeORMQuery} The PostgresSQL condition
+     * @mermaid
+     * sequenceDiagram
+     *   participant Statement
+     *   participant translateOperators
+     *   participant parseCondition
+     *
+     *   Statement->>Statement: parseCondition(condition)
+     *
+     *   Note over Statement: Extract condition parts
+     *
+     *   alt Simple comparison operator
+     *     Statement->>translateOperators: translateOperators(operator)
+     *     translateOperators-->>Statement: Return PostgreSQL operator
+     *     Statement->>Statement: Create condition with column, operator, and value
+     *   else NOT operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: Add NOT to conditions
+     *   else AND/OR operator
+     *     Statement->>Statement: parseCondition(attr1)
+     *     Statement->>Statement: parseCondition(comparison)
+     *     Statement->>Statement: Combine conditions with AND/OR
+     *   end
+     *
+     *   Statement-->>Statement: Return conditions array
+     */
+    protected parseCondition(condition: Condition<M>, tableName: string, qb: SelectQueryBuilder<any>, counter?: number, conditionalOp?: GroupOperator | Operator): TypeORMQuery<M>;
+}

package/lib/query/constants.cjs

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMConst = exports.TypeORMGroupOperator = exports.TypeORMOperator = exports.TypeORMQueryLimit = void 0;
+const types_1 = require("./../types.cjs");
+/**
+ * @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
+ */
+exports.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
+ */
+exports.TypeORMOperator = {
+    EQUAL: types_1.SQLOperator.EQUAL,
+    DIFFERENT: types_1.SQLOperator.NOT_EQUAL,
+    BIGGER: types_1.SQLOperator.GREATER_THAN,
+    BIGGER_EQ: types_1.SQLOperator.GREATER_THAN_OR_EQUAL,
+    SMALLER: types_1.SQLOperator.LESS_THAN,
+    SMALLER_EQ: types_1.SQLOperator.LESS_THAN_OR_EQUAL,
+    BETWEEN: types_1.SQLOperator.BETWEEN,
+    NOT: "NOT",
+    IN: types_1.SQLOperator.IN,
+    IS_NULL: types_1.SQLOperator.IS_NULL,
+    IS_NOT_NULL: types_1.SQLOperator.IS_NOT_NULL,
+    REGEXP: "~",
+    IREGEXP: "~*",
+    LIKE: types_1.SQLOperator.LIKE,
+    ILIKE: types_1.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
+ */
+exports.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
+ */
+exports.TypeORMConst = {
+    NULL: "NULL",
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/query/constants.d.ts

@@ -0,0 +1,52 @@
+import { SQLOperator } from "../types";
+/**
+ * @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 declare 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 declare const TypeORMOperator: Record<string, SQLOperator | string>;
+/**
+ * @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 declare const TypeORMGroupOperator: Record<string, string>;
+/**
+ * @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 declare const TypeORMConst: Record<string, string>;

package/lib/query/index.cjs

@@ -0,0 +1,21 @@
+"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 });
+__exportStar(require("./constants.cjs"), exports);
+__exportStar(require("./Paginator.cjs"), exports);
+__exportStar(require("./Statement.cjs"), exports);
+__exportStar(require("./translate.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcXVlcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLGtEQUE0QjtBQUM1QixrREFBNEI7QUFDNUIsa0RBQTRCO0FBQzVCLGtEQUE0QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnN0YW50c1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vUGFnaW5hdG9yXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9TdGF0ZW1lbnRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RyYW5zbGF0ZVwiO1xuIl19

package/lib/query/index.d.ts

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

package/lib/query/translate.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateOperators = translateOperators;
+const constants_1 = require("./constants.cjs");
+const core_1 = require("@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
+ */
+function translateOperators(operator) {
+    for (const operators of [constants_1.TypeORMOperator, constants_1.TypeORMGroupOperator]) {
+        const el = Object.keys(operators).find((k) => k === operator);
+        if (el)
+            return operators[el];
+    }
+    throw new core_1.QueryError(`Could not find adapter translation for operator ${operator}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/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/raw/postgres.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9zdGdyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmF3L3Bvc3RncmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBEZWZpbml0aW9uIG9mIGEgUG9zdGdyZVNRTCByZXN1bHQgZmllbGQuXG4gKiBAc3VtbWFyeSBEZXNjcmliZXMgbWV0YWRhdGEgZm9yIGEgY29sdW1uIHJldHVybmVkIGluIGEgUG9zdGdyZVNRTCBxdWVyeSByZXN1bHQsIGluY2x1ZGluZyBpZGVudGlmaWVycyBhbmQgdHlwZSBpbmZvcm1hdGlvbi5cbiAqIEBpbnRlcmZhY2UgRmllbGREZWZcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Zm9yLXR5cGVvcm1cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBGaWVsZERlZiB7XG4gIG5hbWU6IHN0cmluZztcbiAgdGFibGVJRDogbnVtYmVyO1xuICBjb2x1bW5JRDogbnVtYmVyO1xuICBkYXRhVHlwZUlEOiBudW1iZXI7XG4gIGRhdGFUeXBlU2l6ZTogbnVtYmVyO1xuICBkYXRhVHlwZU1vZGlmaWVyOiBudW1iZXI7XG4gIGZvcm1hdDogc3RyaW5nO1xufVxuXG4vKipcbiAqIEBkZXNjcmlwdGlvbiBCYXNlIHNoYXBlIGZvciBQb3N0Z3JlU1FMIHF1ZXJ5IHJlc3VsdHMuXG4gKiBAc3VtbWFyeSBDb250YWlucyBjb21tb24gcHJvcGVydGllcyBwcmVzZW50IGluIGFsbCBQb3N0Z3JlU1FMIHF1ZXJ5IHJlc3VsdHMgc3VjaCBhcyB0aGUgZXhlY3V0ZWQgY29tbWFuZCwgcm93IGNvdW50LCBvaWQsIGFuZCBmaWVsZHMgbWV0YWRhdGEuXG4gKiBAaW50ZXJmYWNlIFF1ZXJ5UmVzdWx0QmFzZVxuICogQG1lbWJlck9mIG1vZHVsZTpmb3ItdHlwZW9ybVxuICovXG5leHBvcnQgaW50ZXJmYWNlIFF1ZXJ5UmVzdWx0QmFzZSB7XG4gIGNvbW1hbmQ6IHN0cmluZztcbiAgcm93Q291bnQ6IG51bWJlciB8IG51bGw7XG4gIG9pZDogbnVtYmVyO1xuICBmaWVsZHM6IEZpZWxkRGVmW107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUXVlcnlSZXN1bHRSb3cge1xuICBbY29sdW1uOiBzdHJpbmddOiBhbnk7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUXVlcnlSZXN1bHQ8UiBleHRlbmRzIFF1ZXJ5UmVzdWx0Um93ID0gYW55PlxuICBleHRlbmRzIFF1ZXJ5UmVzdWx0QmFzZSB7XG4gIHJvd3M6IFJbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBRdWVyeUFycmF5UmVzdWx0PFIgZXh0ZW5kcyBhbnlbXSA9IGFueVtdPlxuICBleHRlbmRzIFF1ZXJ5UmVzdWx0QmFzZSB7XG4gIHJvd3M6IFJbXTtcbn1cbiJdfQ==

package/lib/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/sequences/Sequence.cjs

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeORMSequence = void 0;
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const core_1 = require("@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
+ */
+class TypeORMSequence extends core_1.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 core_1.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 db_decorators_1.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 db_decorators_1.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 db_decorators_1.InternalError("Miscalculation of range");
+        return range;
+    }
+}
+exports.TypeORMSequence = TypeORMSequence;
+//# 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/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/sequences/index.cjs

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./Sequence.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VxdWVuY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxpREFBMkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9TZXF1ZW5jZVwiO1xuIl19

package/lib/sequences/index.d.ts

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