@decaf-ts/for-typeorm 0.0.6

package/lib/esm/overrides/Column.d.ts

@@ -0,0 +1,74 @@
+import { ColumnOptions } from "typeorm";
+import { SimpleColumnType, SpatialColumnType, WithLengthColumnType, WithPrecisionColumnType, WithWidthColumnType } from "typeorm/driver/types/ColumnTypes";
+import { ColumnCommonOptions } from "typeorm/decorator/options/ColumnCommonOptions";
+import { SpatialColumnOptions } from "typeorm/decorator/options/SpatialColumnOptions";
+import { ColumnWithLengthOptions } from "typeorm/decorator/options/ColumnWithLengthOptions";
+import { ColumnWithWidthOptions } from "typeorm/decorator/options/ColumnWithWidthOptions";
+import { ColumnNumericOptions } from "typeorm/decorator/options/ColumnNumericOptions";
+import { ColumnEnumOptions } from "typeorm/decorator/options/ColumnEnumOptions";
+import { ColumnHstoreOptions } from "typeorm/decorator/options/ColumnHstoreOptions";
+import { ColumnEmbeddedOptions } from "typeorm/decorator/options/ColumnEmbeddedOptions";
+/**
+ * Column decorator is used to mark a specific class property as a table column. Only properties decorated with this
+ * decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(options: ColumnOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: SimpleColumnType, options?: ColumnCommonOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: SpatialColumnType, options?: ColumnCommonOptions & SpatialColumnOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: WithLengthColumnType, options?: ColumnCommonOptions & ColumnWithLengthOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: WithWidthColumnType, options?: ColumnCommonOptions & ColumnWithWidthOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: WithPrecisionColumnType, options?: ColumnCommonOptions & ColumnNumericOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: "enum", options?: ColumnCommonOptions & ColumnEnumOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: "simple-enum", options?: ColumnCommonOptions & ColumnEnumOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: "set", options?: ColumnCommonOptions & ColumnEnumOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export declare function Column(type: "hstore", options?: ColumnCommonOptions & ColumnHstoreOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ *
+ * Property in entity can be marked as Embedded, and on persist all columns from the embedded are mapped to the
+ * single table of the entity where Embedded is used. And on hydration all columns which supposed to be in the
+ * embedded will be mapped to it from the single table.
+ */
+export declare function Column(type: (type?: any) => Function, options?: ColumnEmbeddedOptions): PropertyDecorator;

package/lib/esm/overrides/Column.js

@@ -0,0 +1,70 @@
+import { ColumnTypeUndefinedError, getMetadataArgsStorage, } from "typeorm";
+import { aggregateOrNewColumn } from "./utils.js";
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ */
+export function Column(typeOrOptions, options) {
+    return function (object, propertyName) {
+        // normalize parameters
+        let type;
+        if (typeof typeOrOptions === "string" ||
+            typeof typeOrOptions === "function") {
+            type = typeOrOptions;
+        }
+        else if (typeOrOptions) {
+            options = typeOrOptions;
+            type = typeOrOptions.type;
+        }
+        if (!options)
+            options = {};
+        // if type is not given explicitly then try to guess it
+        const reflectMetadataType = Reflect && Reflect.getMetadata
+            ? Reflect.getMetadata("design:type", object, propertyName)
+            : undefined;
+        if (!type && reflectMetadataType)
+            // if type is not given explicitly then try to guess it
+            type = reflectMetadataType;
+        // check if there is no type in column options then set type from first function argument, or guessed one
+        if (!options.type && type)
+            options.type = type;
+        // specify HSTORE type if column is HSTORE
+        if (options.type === "hstore" && !options.hstoreType)
+            options.hstoreType = reflectMetadataType === Object ? "object" : "string";
+        if (typeof typeOrOptions === "function") {
+            // register an embedded
+            getMetadataArgsStorage().embeddeds.push({
+                target: object.constructor,
+                propertyName: propertyName,
+                isArray: reflectMetadataType === Array || options.array === true,
+                prefix: options.prefix !== undefined ? options.prefix : undefined,
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+                type: typeOrOptions,
+            });
+        }
+        else {
+            // register a regular column
+            // if we still don't have a type then we need to give error to user that type is required
+            if (!options.type)
+                throw new ColumnTypeUndefinedError(object, propertyName);
+            // create unique
+            if (options.unique === true)
+                getMetadataArgsStorage().uniques.push({
+                    target: object.constructor,
+                    columns: [propertyName],
+                });
+            const columns = getMetadataArgsStorage().columns;
+            aggregateOrNewColumn(object.constructor, propertyName, columns, options);
+            if (options.generated) {
+                getMetadataArgsStorage().generations.push({
+                    target: object.constructor,
+                    propertyName: propertyName,
+                    strategy: typeof options.generated === "string"
+                        ? options.generated
+                        : "increment",
+                });
+            }
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Column.js","sourceRoot":"","sources":["../../../src/overrides/Column.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,SAAS,CAAC;AAkBjB,OAAO,EAAE,oBAAoB,EAAE,mBAAgB;AA8G/C;;;GAGG;AACH,MAAM,UAAU,MAAM,CACpB,aAG2C,EAC3C,OAA+C;IAE/C,OAAO,UAAU,MAAc,EAAE,YAAiB;QAChD,uBAAuB;QACvB,IAAI,IAA4B,CAAC;QACjC,IACE,OAAO,aAAa,KAAK,QAAQ;YACjC,OAAO,aAAa,KAAK,UAAU,EACnC,CAAC;YACD,IAAI,GAAe,aAAa,CAAC;QACnC,CAAC;aAAM,IAAI,aAAa,EAAE,CAAC;YACzB,OAAO,GAAkB,aAAa,CAAC;YACvC,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC;QAC5B,CAAC;QACD,IAAI,CAAC,OAAO;YAAE,OAAO,GAAG,EAAmB,CAAC;QAE5C,uDAAuD;QACvD,MAAM,mBAAmB,GACvB,OAAO,IAAK,OAAe,CAAC,WAAW;YACrC,CAAC,CAAE,OAAe,CAAC,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,YAAY,CAAC;YACnE,CAAC,CAAC,SAAS,CAAC;QAChB,IAAI,CAAC,IAAI,IAAI,mBAAmB;YAC9B,uDAAuD;YACvD,IAAI,GAAG,mBAAmB,CAAC;QAE7B,yGAAyG;QACzG,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,IAAI;YAAE,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;QAE/C,0CAA0C;QAC1C,IAAI,OAAO,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,OAAO,CAAC,UAAU;YAClD,OAAO,CAAC,UAAU,GAAG,mBAAmB,KAAK,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC;QAE5E,IAAI,OAAO,aAAa,KAAK,UAAU,EAAE,CAAC;YACxC,uBAAuB;YACvB,sBAAsB,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC;gBACtC,MAAM,EAAE,MAAM,CAAC,WAAW;gBAC1B,YAAY,EAAE,YAAY;gBAC1B,OAAO,EAAE,mBAAmB,KAAK,KAAK,IAAI,OAAO,CAAC,KAAK,KAAK,IAAI;gBAChE,MAAM,EAAE,OAAO,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS;gBACjE,sEAAsE;gBACtE,IAAI,EAAE,aAAyC;aACxB,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,4BAA4B;YAE5B,yFAAyF;YACzF,IAAI,CAAC,OAAO,CAAC,IAAI;gBACf,MAAM,IAAI,wBAAwB,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;YAE3D,gBAAgB;YAChB,IAAI,OAAO,CAAC,MAAM,KAAK,IAAI;gBACzB,sBAAsB,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;oBACpC,MAAM,EAAE,MAAM,CAAC,WAAW;oBAC1B,OAAO,EAAE,CAAC,YAAY,CAAC;iBACxB,CAAC,CAAC;YAEL,MAAM,OAAO,GAAG,sBAAsB,EAAE,CAAC,OAAO,CAAC;YACjD,oBAAoB,CAAC,MAAM,CAAC,WAAW,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YAEzE,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;gBACtB,sBAAsB,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC;oBACxC,MAAM,EAAE,MAAM,CAAC,WAAW;oBAC1B,YAAY,EAAE,YAAY;oBAC1B,QAAQ,EACN,OAAO,OAAO,CAAC,SAAS,KAAK,QAAQ;wBACnC,CAAC,CAAC,OAAO,CAAC,SAAS;wBACnB,CAAC,CAAC,WAAW;iBACO,CAAC,CAAC;YAC9B,CAAC;QACH,CAAC;IACH,CAAC,CAAC;AACJ,CAAC","sourcesContent":["import { GeneratedMetadataArgs } from \"typeorm/metadata-args/GeneratedMetadataArgs\";\nimport {\n  ColumnOptions,\n  ColumnType,\n  ColumnTypeUndefinedError,\n  getMetadataArgsStorage,\n} from \"typeorm\";\nimport {\n  SimpleColumnType,\n  SpatialColumnType,\n  WithLengthColumnType,\n  WithPrecisionColumnType,\n  WithWidthColumnType,\n} from \"typeorm/driver/types/ColumnTypes\";\nimport { ColumnCommonOptions } from \"typeorm/decorator/options/ColumnCommonOptions\";\nimport { SpatialColumnOptions } from \"typeorm/decorator/options/SpatialColumnOptions\";\nimport { ColumnWithLengthOptions } from \"typeorm/decorator/options/ColumnWithLengthOptions\";\nimport { ColumnWithWidthOptions } from \"typeorm/decorator/options/ColumnWithWidthOptions\";\nimport { ColumnNumericOptions } from \"typeorm/decorator/options/ColumnNumericOptions\";\nimport { ColumnEnumOptions } from \"typeorm/decorator/options/ColumnEnumOptions\";\nimport { ColumnHstoreOptions } from \"typeorm/decorator/options/ColumnHstoreOptions\";\nimport { ColumnEmbeddedOptions } from \"typeorm/decorator/options/ColumnEmbeddedOptions\";\nimport { EmbeddedMetadataArgs } from \"typeorm/metadata-args/EmbeddedMetadataArgs\";\nimport { ColumnMetadataArgs } from \"typeorm/metadata-args/ColumnMetadataArgs\";\nimport { aggregateOrNewColumn } from \"./utils\";\n\n/**\n * Column decorator is used to mark a specific class property as a table column. Only properties decorated with this\n * decorator will be persisted to the database when entity be saved.\n */\nexport function Column(): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(options: ColumnOptions): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: SimpleColumnType,\n  options?: ColumnCommonOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: SpatialColumnType,\n  options?: ColumnCommonOptions & SpatialColumnOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: WithLengthColumnType,\n  options?: ColumnCommonOptions & ColumnWithLengthOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: WithWidthColumnType,\n  options?: ColumnCommonOptions & ColumnWithWidthOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: WithPrecisionColumnType,\n  options?: ColumnCommonOptions & ColumnNumericOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: \"enum\",\n  options?: ColumnCommonOptions & ColumnEnumOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: \"simple-enum\",\n  options?: ColumnCommonOptions & ColumnEnumOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  type: \"set\",\n  options?: ColumnCommonOptions & ColumnEnumOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\n// @ts-expect-error some typeorm thing\nexport function Column(\n  type: \"hstore\",\n  options?: ColumnCommonOptions & ColumnHstoreOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n *\n * Property in entity can be marked as Embedded, and on persist all columns from the embedded are mapped to the\n * single table of the entity where Embedded is used. And on hydration all columns which supposed to be in the\n * embedded will be mapped to it from the single table.\n */\nexport function Column(\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  type: (type?: any) => Function,\n  options?: ColumnEmbeddedOptions\n): PropertyDecorator;\n\n/**\n * Column decorator is used to mark a specific class property as a table column.\n * Only properties decorated with this decorator will be persisted to the database when entity be saved.\n */\nexport function Column(\n  typeOrOptions?: // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  | ((type?: any) => Function)\n    | ColumnType\n    | (ColumnOptions & ColumnEmbeddedOptions),\n  options?: ColumnOptions & ColumnEmbeddedOptions\n): PropertyDecorator {\n  return function (object: object, propertyName: any) {\n    // normalize parameters\n    let type: ColumnType | undefined;\n    if (\n      typeof typeOrOptions === \"string\" ||\n      typeof typeOrOptions === \"function\"\n    ) {\n      type = <ColumnType>typeOrOptions;\n    } else if (typeOrOptions) {\n      options = <ColumnOptions>typeOrOptions;\n      type = typeOrOptions.type;\n    }\n    if (!options) options = {} as ColumnOptions;\n\n    // if type is not given explicitly then try to guess it\n    const reflectMetadataType =\n      Reflect && (Reflect as any).getMetadata\n        ? (Reflect as any).getMetadata(\"design:type\", object, propertyName)\n        : undefined;\n    if (!type && reflectMetadataType)\n      // if type is not given explicitly then try to guess it\n      type = reflectMetadataType;\n\n    // check if there is no type in column options then set type from first function argument, or guessed one\n    if (!options.type && type) options.type = type;\n\n    // specify HSTORE type if column is HSTORE\n    if (options.type === \"hstore\" && !options.hstoreType)\n      options.hstoreType = reflectMetadataType === Object ? \"object\" : \"string\";\n\n    if (typeof typeOrOptions === \"function\") {\n      // register an embedded\n      getMetadataArgsStorage().embeddeds.push({\n        target: object.constructor,\n        propertyName: propertyName,\n        isArray: reflectMetadataType === Array || options.array === true,\n        prefix: options.prefix !== undefined ? options.prefix : undefined,\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n        type: typeOrOptions as (type?: any) => Function,\n      } as EmbeddedMetadataArgs);\n    } else {\n      // register a regular column\n\n      // if we still don't have a type then we need to give error to user that type is required\n      if (!options.type)\n        throw new ColumnTypeUndefinedError(object, propertyName);\n\n      // create unique\n      if (options.unique === true)\n        getMetadataArgsStorage().uniques.push({\n          target: object.constructor,\n          columns: [propertyName],\n        });\n\n      const columns = getMetadataArgsStorage().columns;\n      aggregateOrNewColumn(object.constructor, propertyName, columns, options);\n\n      if (options.generated) {\n        getMetadataArgsStorage().generations.push({\n          target: object.constructor,\n          propertyName: propertyName,\n          strategy:\n            typeof options.generated === \"string\"\n              ? options.generated\n              : \"increment\",\n        } as GeneratedMetadataArgs);\n      }\n    }\n  };\n}\n"]}

package/lib/esm/overrides/CreateDateColumn.d.ts

@@ -0,0 +1,2 @@
+import { ColumnOptions } from "typeorm";
+export declare function CreateDateColumn(options?: ColumnOptions): PropertyDecorator;

package/lib/esm/overrides/CreateDateColumn.js

@@ -0,0 +1,9 @@
+import { getMetadataArgsStorage } from "typeorm";
+import { aggregateOrNewColumn } from "./utils.js";
+export function CreateDateColumn(options) {
+    return function (object, propertyName) {
+        const columns = getMetadataArgsStorage().columns;
+        aggregateOrNewColumn(object.constructor, propertyName, columns, options || {}, "createDate");
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ3JlYXRlRGF0ZUNvbHVtbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9vdmVycmlkZXMvQ3JlYXRlRGF0ZUNvbHVtbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWlCLHNCQUFzQixFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ2hFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxtQkFBZ0I7QUFFL0MsTUFBTSxVQUFVLGdCQUFnQixDQUFDLE9BQXVCO0lBQ3RELE9BQU8sVUFBVSxNQUFXLEVBQUUsWUFBaUI7UUFDN0MsTUFBTSxPQUFPLEdBQUcsc0JBQXNCLEVBQUUsQ0FBQyxPQUFPLENBQUM7UUFDakQsb0JBQW9CLENBQ2xCLE1BQU0sQ0FBQyxXQUFXLEVBQ2xCLFlBQVksRUFDWixPQUFPLEVBQ1AsT0FBTyxJQUFJLEVBQUUsRUFDYixZQUFZLENBQ2IsQ0FBQztJQUNKLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb2x1bW5PcHRpb25zLCBnZXRNZXRhZGF0YUFyZ3NTdG9yYWdlIH0gZnJvbSBcInR5cGVvcm1cIjtcbmltcG9ydCB7IGFnZ3JlZ2F0ZU9yTmV3Q29sdW1uIH0gZnJvbSBcIi4vdXRpbHNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIENyZWF0ZURhdGVDb2x1bW4ob3B0aW9ucz86IENvbHVtbk9wdGlvbnMpOiBQcm9wZXJ0eURlY29yYXRvciB7XG4gIHJldHVybiBmdW5jdGlvbiAob2JqZWN0OiBhbnksIHByb3BlcnR5TmFtZTogYW55KSB7XG4gICAgY29uc3QgY29sdW1ucyA9IGdldE1ldGFkYXRhQXJnc1N0b3JhZ2UoKS5jb2x1bW5zO1xuICAgIGFnZ3JlZ2F0ZU9yTmV3Q29sdW1uKFxuICAgICAgb2JqZWN0LmNvbnN0cnVjdG9yLFxuICAgICAgcHJvcGVydHlOYW1lLFxuICAgICAgY29sdW1ucyxcbiAgICAgIG9wdGlvbnMgfHwge30sXG4gICAgICBcImNyZWF0ZURhdGVcIlxuICAgICk7XG4gIH07XG59XG4iXX0=

package/lib/esm/overrides/Entity.d.ts

@@ -0,0 +1,11 @@
+import { EntityOptions } from "typeorm";
+/**
+ * This decorator is used to mark classes that will be an entity (table or document depend on database type).
+ * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.
+ */
+export declare function Entity(options?: EntityOptions): ClassDecorator;
+/**
+ * This decorator is used to mark classes that will be an entity (table or document depend on database type).
+ * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.
+ */
+export declare function Entity(name?: string, options?: EntityOptions): ClassDecorator;

package/lib/esm/overrides/Entity.js

@@ -0,0 +1,28 @@
+import { getMetadataArgsStorage } from "typeorm";
+import { ObjectUtils } from "typeorm/util/ObjectUtils";
+/**
+ * This decorator is used to mark classes that will be an entity (table or document depend on database type).
+ * Database schema will be created for all classes decorated with it, and Repository can be retrieved and used for it.
+ */
+export function Entity(nameOrOptions, maybeOptions) {
+    const options = (ObjectUtils.isObject(nameOrOptions)
+        ? nameOrOptions
+        : maybeOptions) || {};
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : options.name;
+    return function (target) {
+        const tables = getMetadataArgsStorage().tables;
+        tables.push({
+            target: target,
+            name: name,
+            type: "regular",
+            orderBy: options.orderBy ? options.orderBy : undefined,
+            engine: options.engine ? options.engine : undefined,
+            database: options.database ? options.database : undefined,
+            schema: options.schema ? options.schema : undefined,
+            synchronize: options.synchronize,
+            withoutRowid: options.withoutRowid,
+            comment: options.comment ? options.comment : undefined,
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/overrides/PrimaryColumn.d.ts

@@ -0,0 +1,20 @@
+import { ColumnOptions, ColumnType } from "typeorm";
+/**
+ * Describes all primary key column's options.
+ * If specified, the nullable field must be set to false.
+ */
+export type PrimaryColumnOptions = ColumnOptions & {
+    nullable?: false;
+};
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ * Primary columns also creates a PRIMARY KEY for this column in a db.
+ */
+export declare function PrimaryColumn(options?: PrimaryColumnOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ * Primary columns also creates a PRIMARY KEY for this column in a db.
+ */
+export declare function PrimaryColumn(type?: ColumnType, options?: PrimaryColumnOptions): PropertyDecorator;

package/lib/esm/overrides/PrimaryColumn.js

@@ -0,0 +1,53 @@
+import { ColumnTypeUndefinedError, getMetadataArgsStorage, PrimaryColumnCannotBeNullableError, } from "typeorm";
+import { aggregateOrNewColumn } from "./utils.js";
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ * Primary columns also creates a PRIMARY KEY for this column in a db.
+ */
+export function PrimaryColumn(typeOrOptions, options) {
+    return function (object, propertyName) {
+        // normalize parameters
+        let type;
+        if (typeof typeOrOptions === "string" ||
+            typeOrOptions === String ||
+            typeOrOptions === Boolean ||
+            typeOrOptions === Number) {
+            type = typeOrOptions;
+        }
+        else {
+            options = Object.assign({}, typeOrOptions);
+        }
+        if (!options)
+            options = {};
+        // if type is not given explicitly then try to guess it
+        const reflectMetadataType = Reflect && Reflect.getMetadata
+            ? Reflect.getMetadata("design:type", object, propertyName)
+            : undefined;
+        if (!type && reflectMetadataType)
+            type = reflectMetadataType;
+        // check if there is no type in column options then set type from first function argument, or guessed one
+        if (!options.type && type)
+            options.type = type;
+        // if we still don't have a type then we need to give error to user that type is required
+        if (!options.type)
+            throw new ColumnTypeUndefinedError(object, propertyName);
+        // check if column is not nullable, because we cannot allow a primary key to be nullable
+        if (options.nullable)
+            throw new PrimaryColumnCannotBeNullableError(object, propertyName);
+        // explicitly set a primary to column options
+        options.primary = true;
+        const columns = getMetadataArgsStorage().columns;
+        aggregateOrNewColumn(object.constructor, propertyName, columns, options);
+        if (options.generated) {
+            getMetadataArgsStorage().generations.push({
+                target: object.constructor,
+                propertyName: propertyName,
+                strategy: typeof options.generated === "string"
+                    ? options.generated
+                    : "increment",
+            });
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/overrides/PrimaryGeneratedColumn.d.ts

@@ -0,0 +1,24 @@
+import { PrimaryGeneratedColumnNumericOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnNumericOptions";
+import { PrimaryGeneratedColumnUUIDOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnUUIDOptions";
+import { PrimaryGeneratedColumnIdentityOptions } from "typeorm/decorator/options/PrimaryGeneratedColumnIdentityOptions";
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(options: PrimaryGeneratedColumnNumericOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(strategy: "increment", options?: PrimaryGeneratedColumnNumericOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(strategy: "uuid", options?: PrimaryGeneratedColumnUUIDOptions): PropertyDecorator;
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ */
+export declare function PrimaryGeneratedColumn(strategy: "rowid", options?: PrimaryGeneratedColumnUUIDOptions): PropertyDecorator;
+export declare function PrimaryGeneratedColumn(strategy: "identity", options?: PrimaryGeneratedColumnIdentityOptions): PropertyDecorator;

package/lib/esm/overrides/PrimaryGeneratedColumn.js

@@ -0,0 +1,51 @@
+import { ObjectUtils } from "typeorm/util/ObjectUtils";
+import { getMetadataArgsStorage } from "typeorm";
+import { aggregateOrNewColumn } from "./utils.js";
+/**
+ * Column decorator is used to mark a specific class property as a table column.
+ * Only properties decorated with this decorator will be persisted to the database when entity be saved.
+ * This column creates an integer PRIMARY COLUMN with generated set to true.
+ */
+export function PrimaryGeneratedColumn(strategyOrOptions, maybeOptions) {
+    // normalize parameters
+    const options = {};
+    let strategy;
+    if (strategyOrOptions) {
+        if (typeof strategyOrOptions === "string")
+            strategy = strategyOrOptions;
+        if (ObjectUtils.isObject(strategyOrOptions)) {
+            strategy = "increment";
+            Object.assign(options, strategyOrOptions);
+        }
+    }
+    else {
+        strategy = "increment";
+    }
+    if (ObjectUtils.isObject(maybeOptions))
+        Object.assign(options, maybeOptions);
+    return function (object, propertyName) {
+        // if column type is not explicitly set then determine it based on generation strategy
+        if (!options.type) {
+            if (strategy === "increment" || strategy === "identity") {
+                options.type = Number;
+            }
+            else if (strategy === "uuid") {
+                options.type = "uuid";
+            }
+            else if (strategy === "rowid") {
+                options.type = "int";
+            }
+        }
+        // explicitly set a primary and generated to column options
+        options.primary = true;
+        const columns = getMetadataArgsStorage().columns;
+        aggregateOrNewColumn(object.constructor, propertyName, columns, options);
+        // register generated metadata args
+        getMetadataArgsStorage().generations.push({
+            target: object.constructor,
+            propertyName: propertyName,
+            strategy: strategy,
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/overrides/UpdateDateColumn.d.ts

@@ -0,0 +1,2 @@
+import { ColumnOptions } from "typeorm";
+export declare function UpdateDateColumn(options?: ColumnOptions): PropertyDecorator;

package/lib/esm/overrides/UpdateDateColumn.js

@@ -0,0 +1,9 @@
+import { getMetadataArgsStorage } from "typeorm";
+import { aggregateOrNewColumn } from "./utils.js";
+export function UpdateDateColumn(options) {
+    return function (object, propertyName) {
+        const columns = getMetadataArgsStorage().columns;
+        aggregateOrNewColumn(object.constructor, propertyName, columns, options || {}, "updateDate");
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiVXBkYXRlRGF0ZUNvbHVtbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9vdmVycmlkZXMvVXBkYXRlRGF0ZUNvbHVtbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWlCLHNCQUFzQixFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ2hFLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxtQkFBZ0I7QUFFL0MsTUFBTSxVQUFVLGdCQUFnQixDQUFDLE9BQXVCO0lBQ3RELE9BQU8sVUFBVSxNQUFXLEVBQUUsWUFBaUI7UUFDN0MsTUFBTSxPQUFPLEdBQUcsc0JBQXNCLEVBQUUsQ0FBQyxPQUFPLENBQUM7UUFDakQsb0JBQW9CLENBQ2xCLE1BQU0sQ0FBQyxXQUFXLEVBQ2xCLFlBQVksRUFDWixPQUFPLEVBQ1AsT0FBTyxJQUFJLEVBQUUsRUFDYixZQUFZLENBQ2IsQ0FBQztJQUNKLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb2x1bW5PcHRpb25zLCBnZXRNZXRhZGF0YUFyZ3NTdG9yYWdlIH0gZnJvbSBcInR5cGVvcm1cIjtcbmltcG9ydCB7IGFnZ3JlZ2F0ZU9yTmV3Q29sdW1uIH0gZnJvbSBcIi4vdXRpbHNcIjtcblxuZXhwb3J0IGZ1bmN0aW9uIFVwZGF0ZURhdGVDb2x1bW4ob3B0aW9ucz86IENvbHVtbk9wdGlvbnMpOiBQcm9wZXJ0eURlY29yYXRvciB7XG4gIHJldHVybiBmdW5jdGlvbiAob2JqZWN0OiBhbnksIHByb3BlcnR5TmFtZTogYW55KSB7XG4gICAgY29uc3QgY29sdW1ucyA9IGdldE1ldGFkYXRhQXJnc1N0b3JhZ2UoKS5jb2x1bW5zO1xuICAgIGFnZ3JlZ2F0ZU9yTmV3Q29sdW1uKFxuICAgICAgb2JqZWN0LmNvbnN0cnVjdG9yLFxuICAgICAgcHJvcGVydHlOYW1lLFxuICAgICAgY29sdW1ucyxcbiAgICAgIG9wdGlvbnMgfHwge30sXG4gICAgICBcInVwZGF0ZURhdGVcIlxuICAgICk7XG4gIH07XG59XG4iXX0=

package/lib/esm/overrides/utils.d.ts

@@ -0,0 +1,2 @@
+import { ColumnMetadataArgs } from "typeorm/metadata-args/ColumnMetadataArgs";
+export declare function aggregateOrNewColumn(target: any, property: string, columns: ColumnMetadataArgs[], options?: any, mode?: string): void;

package/lib/esm/overrides/utils.js

@@ -0,0 +1,29 @@
+export function aggregateOrNewColumn(target, property, columns, options = {}, mode = "regular") {
+    const cols = columns.filter((c) => c.target === target && c.propertyName === property);
+    if (cols.length > 1)
+        throw new Error(`Multiple columns for ${property} found for given target: ${columns.map((c) => c.propertyName).join(", ")}`);
+    if (cols.length === 0) {
+        columns.push({
+            target: target,
+            propertyName: property,
+            mode: mode,
+            options: options,
+        });
+        return;
+    }
+    const column = cols[0];
+    Object.defineProperty(column, "options", {
+        value: { ...column.options, ...options },
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+    if (mode !== "regular")
+        Object.defineProperty(column, "mode", {
+            value: mode,
+            writable: true,
+            enumerable: true,
+            configurable: true,
+        });
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvb3ZlcnJpZGVzL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxvQkFBb0IsQ0FDbEMsTUFBVyxFQUNYLFFBQWdCLEVBQ2hCLE9BQTZCLEVBQzdCLFVBQWUsRUFBRSxFQUNqQixPQUFlLFNBQVM7SUFFeEIsTUFBTSxJQUFJLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FDekIsQ0FBQyxDQUFxQixFQUFFLEVBQUUsQ0FDeEIsQ0FBQyxDQUFDLE1BQU0sS0FBSyxNQUFNLElBQUksQ0FBQyxDQUFDLFlBQVksS0FBSyxRQUFRLENBQ3JELENBQUM7SUFFRixJQUFJLElBQUksQ0FBQyxNQUFNLEdBQUcsQ0FBQztRQUNqQixNQUFNLElBQUksS0FBSyxDQUNiLHdCQUF3QixRQUFRLDRCQUE0QixPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUMsWUFBWSxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQzVHLENBQUM7SUFFSixJQUFJLElBQUksQ0FBQyxNQUFNLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDdEIsT0FBTyxDQUFDLElBQUksQ0FBQztZQUNYLE1BQU0sRUFBRSxNQUFNO1lBQ2QsWUFBWSxFQUFFLFFBQVE7WUFDdEIsSUFBSSxFQUFFLElBQUk7WUFDVixPQUFPLEVBQUUsT0FBTztTQUNLLENBQUMsQ0FBQztRQUN6QixPQUFPO0lBQ1QsQ0FBQztJQUVELE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUN2QixNQUFNLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRSxTQUFTLEVBQUU7UUFDdkMsS0FBSyxFQUFFLEVBQUUsR0FBRyxNQUFNLENBQUMsT0FBTyxFQUFFLEdBQUcsT0FBTyxFQUFFO1FBQ3hDLFFBQVEsRUFBRSxJQUFJO1FBQ2QsVUFBVSxFQUFFLElBQUk7UUFDaEIsWUFBWSxFQUFFLElBQUk7S0FDbkIsQ0FBQyxDQUFDO0lBRUgsSUFBSSxJQUFJLEtBQUssU0FBUztRQUNwQixNQUFNLENBQUMsY0FBYyxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUU7WUFDcEMsS0FBSyxFQUFFLElBQUk7WUFDWCxRQUFRLEVBQUUsSUFBSTtZQUNkLFVBQVUsRUFBRSxJQUFJO1lBQ2hCLFlBQVksRUFBRSxJQUFJO1NBQ25CLENBQUMsQ0FBQztBQUNQLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb2x1bW5NZXRhZGF0YUFyZ3MgfSBmcm9tIFwidHlwZW9ybS9tZXRhZGF0YS1hcmdzL0NvbHVtbk1ldGFkYXRhQXJnc1wiO1xuXG5leHBvcnQgZnVuY3Rpb24gYWdncmVnYXRlT3JOZXdDb2x1bW4oXG4gIHRhcmdldDogYW55LFxuICBwcm9wZXJ0eTogc3RyaW5nLFxuICBjb2x1bW5zOiBDb2x1bW5NZXRhZGF0YUFyZ3NbXSxcbiAgb3B0aW9uczogYW55ID0ge30sXG4gIG1vZGU6IHN0cmluZyA9IFwicmVndWxhclwiXG4pIHtcbiAgY29uc3QgY29scyA9IGNvbHVtbnMuZmlsdGVyKFxuICAgIChjOiBDb2x1bW5NZXRhZGF0YUFyZ3MpID0+XG4gICAgICBjLnRhcmdldCA9PT0gdGFyZ2V0ICYmIGMucHJvcGVydHlOYW1lID09PSBwcm9wZXJ0eVxuICApO1xuXG4gIGlmIChjb2xzLmxlbmd0aCA+IDEpXG4gICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgYE11bHRpcGxlIGNvbHVtbnMgZm9yICR7cHJvcGVydHl9IGZvdW5kIGZvciBnaXZlbiB0YXJnZXQ6ICR7Y29sdW1ucy5tYXAoKGMpID0+IGMucHJvcGVydHlOYW1lKS5qb2luKFwiLCBcIil9YFxuICAgICk7XG5cbiAgaWYgKGNvbHMubGVuZ3RoID09PSAwKSB7XG4gICAgY29sdW1ucy5wdXNoKHtcbiAgICAgIHRhcmdldDogdGFyZ2V0LFxuICAgICAgcHJvcGVydHlOYW1lOiBwcm9wZXJ0eSxcbiAgICAgIG1vZGU6IG1vZGUsXG4gICAgICBvcHRpb25zOiBvcHRpb25zLFxuICAgIH0gYXMgQ29sdW1uTWV0YWRhdGFBcmdzKTtcbiAgICByZXR1cm47XG4gIH1cblxuICBjb25zdCBjb2x1bW4gPSBjb2xzWzBdO1xuICBPYmplY3QuZGVmaW5lUHJvcGVydHkoY29sdW1uLCBcIm9wdGlvbnNcIiwge1xuICAgIHZhbHVlOiB7IC4uLmNvbHVtbi5vcHRpb25zLCAuLi5vcHRpb25zIH0sXG4gICAgd3JpdGFibGU6IHRydWUsXG4gICAgZW51bWVyYWJsZTogdHJ1ZSxcbiAgICBjb25maWd1cmFibGU6IHRydWUsXG4gIH0pO1xuXG4gIGlmIChtb2RlICE9PSBcInJlZ3VsYXJcIilcbiAgICBPYmplY3QuZGVmaW5lUHJvcGVydHkoY29sdW1uLCBcIm1vZGVcIiwge1xuICAgICAgdmFsdWU6IG1vZGUsXG4gICAgICB3cml0YWJsZTogdHJ1ZSxcbiAgICAgIGVudW1lcmFibGU6IHRydWUsXG4gICAgICBjb25maWd1cmFibGU6IHRydWUsXG4gICAgfSk7XG59XG4iXX0=

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

@@ -0,0 +1,86 @@
+import { Paginator } from "@decaf-ts/core";
+import { TypeORMQuery } from "../types";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { TypeORMAdapter } from "../TypeORMAdapter";
+import { Repository as Repo } from "typeorm";
+/**
+ * @description Paginator for TypeORM query results.
+ * @summary Implements pagination for TypeORM-built queries using take/skip for efficient navigation through result sets.
+ * @template M The model type that extends Model.
+ * @template R The result type.
+ * @param {TypeORMAdapter} adapter The TypeORM adapter.
+ * @param {TypeORMQuery} query The query container to paginate.
+ * @param {number} size The page size.
+ * @param {Constructor<M>} clazz The model constructor.
+ * @class TypeORMPaginator
+ * @example
+ * // Example of using TypeORMPaginator
+ * const paginator = new TypeORMPaginator(adapter, { query: qb }, 10, User);
+ * const page1 = await paginator.page(1);
+ * const page2 = await paginator.page(2);
+ */
+export declare class TypeORMPaginator<M extends Model, R> extends Paginator<M, R, TypeORMQuery> {
+    /**
+     * @description Gets the total number of pages
+     * @summary Returns the total number of pages based on the record count and page size
+     * @return {number} The total number of pages
+     */
+    get total(): number;
+    /**
+     * @description Gets the total record count
+     * @summary Returns the total number of records matching the query
+     * @return {number} The total record count
+     */
+    get count(): number;
+    private __repo?;
+    protected get repo(): Repo<any>;
+    /**
+     * @description Creates a new TypeORMPaginator instance.
+     * @summary Initializes a paginator for TypeORM query results.
+     * @param {TypeORMAdapter} adapter The TypeORM adapter.
+     * @param {TypeORMQuery} query The TypeORM query container to paginate.
+     * @param {number} size The page size.
+     * @param {Constructor<M>} clazz The model constructor.
+     */
+    constructor(adapter: TypeORMAdapter, query: TypeORMQuery, size: number, clazz: Constructor<M>);
+    /**
+     * @description Prepares a query for pagination
+     * @summary Modifies the raw query to include pagination parameters
+     * @param {TypeORMQuery} rawStatement - The original PostgreSQL query
+     * @return {TypeORMQuery} The prepared query with pagination parameters
+     */
+    protected prepare(rawStatement: TypeORMQuery): TypeORMQuery;
+    /**
+     * @description Retrieves a specific page of results.
+     * @summary Executes the query with pagination and processes the results.
+     * @param {number} [page=1] The page number to retrieve.
+     * @return {Promise<R[]>} A promise that resolves to an array of results.
+     * @throws {PagingError} If trying to access an invalid page or if no class is defined.
+     * @mermaid
+     * sequenceDiagram
+     *   participant Client
+     *   participant Paginator as TypeORMPaginator
+     *   participant Adapter
+     *   participant DB as Database
+     *
+     *   Client->>Paginator: page(pageNumber)
+     *   Note over Paginator: Prepare options (skip/take)
+     *
+     *   alt First time or need count
+     *     Paginator->>Adapter: Get count
+     *     Adapter->>DB: Execute COUNT
+     *     DB-->>Adapter: count
+     *     Adapter-->>Paginator: count
+     *     Paginator->>Paginator: Calculate total pages
+     *   end
+     *
+     *   Paginator->>Adapter: Execute query
+     *   Adapter->>DB: findAndCount(options)
+     *   DB-->>Adapter: rows, count
+     *   Adapter-->>Paginator: rows, count
+     *
+     *   Paginator->>Paginator: Map rows to models
+     *   Paginator-->>Client: results
+     */
+    page(page?: number): Promise<R[]>;
+}