@decaf-ts/for-typeorm 0.0.6

package/lib/index.d.ts

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

package/lib/indexes/generator.cjs

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

package/lib/indexes/generator.d.ts

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

package/lib/indexes/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("./generator.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXhlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsa0RBQTRCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vZ2VuZXJhdG9yXCI7XG4iXX0=

package/lib/indexes/index.d.ts

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

package/lib/overrides/Column.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Column = Column;
+const typeorm_1 = require("typeorm");
+const utils_1 = require("./utils.cjs");
+/**
+ * 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.
+ */
+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
+            (0, typeorm_1.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 typeorm_1.ColumnTypeUndefinedError(object, propertyName);
+            // create unique
+            if (options.unique === true)
+                (0, typeorm_1.getMetadataArgsStorage)().uniques.push({
+                    target: object.constructor,
+                    columns: [propertyName],
+                });
+            const columns = (0, typeorm_1.getMetadataArgsStorage)().columns;
+            (0, utils_1.aggregateOrNewColumn)(object.constructor, propertyName, columns, options);
+            if (options.generated) {
+                (0, typeorm_1.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":";;AA0IA,wBA4EC;AArND,qCAKiB;AAkBjB,uCAA+C;AA8G/C;;;GAGG;AACH,SAAgB,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,IAAA,gCAAsB,GAAE,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,kCAAwB,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;YAE3D,gBAAgB;YAChB,IAAI,OAAO,CAAC,MAAM,KAAK,IAAI;gBACzB,IAAA,gCAAsB,GAAE,CAAC,OAAO,CAAC,IAAI,CAAC;oBACpC,MAAM,EAAE,MAAM,CAAC,WAAW;oBAC1B,OAAO,EAAE,CAAC,YAAY,CAAC;iBACxB,CAAC,CAAC;YAEL,MAAM,OAAO,GAAG,IAAA,gCAAsB,GAAE,CAAC,OAAO,CAAC;YACjD,IAAA,4BAAoB,EAAC,MAAM,CAAC,WAAW,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;YAEzE,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;gBACtB,IAAA,gCAAsB,GAAE,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/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/overrides/CreateDateColumn.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDateColumn = CreateDateColumn;
+const typeorm_1 = require("typeorm");
+const utils_1 = require("./utils.cjs");
+function CreateDateColumn(options) {
+    return function (object, propertyName) {
+        const columns = (0, typeorm_1.getMetadataArgsStorage)().columns;
+        (0, utils_1.aggregateOrNewColumn)(object.constructor, propertyName, columns, options || {}, "createDate");
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ3JlYXRlRGF0ZUNvbHVtbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vdmVycmlkZXMvQ3JlYXRlRGF0ZUNvbHVtbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUdBLDRDQVdDO0FBZEQscUNBQWdFO0FBQ2hFLHVDQUErQztBQUUvQyxTQUFnQixnQkFBZ0IsQ0FBQyxPQUF1QjtJQUN0RCxPQUFPLFVBQVUsTUFBVyxFQUFFLFlBQWlCO1FBQzdDLE1BQU0sT0FBTyxHQUFHLElBQUEsZ0NBQXNCLEdBQUUsQ0FBQyxPQUFPLENBQUM7UUFDakQsSUFBQSw0QkFBb0IsRUFDbEIsTUFBTSxDQUFDLFdBQVcsRUFDbEIsWUFBWSxFQUNaLE9BQU8sRUFDUCxPQUFPLElBQUksRUFBRSxFQUNiLFlBQVksQ0FDYixDQUFDO0lBQ0osQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbHVtbk9wdGlvbnMsIGdldE1ldGFkYXRhQXJnc1N0b3JhZ2UgfSBmcm9tIFwidHlwZW9ybVwiO1xuaW1wb3J0IHsgYWdncmVnYXRlT3JOZXdDb2x1bW4gfSBmcm9tIFwiLi91dGlsc1wiO1xuXG5leHBvcnQgZnVuY3Rpb24gQ3JlYXRlRGF0ZUNvbHVtbihvcHRpb25zPzogQ29sdW1uT3B0aW9ucyk6IFByb3BlcnR5RGVjb3JhdG9yIHtcbiAgcmV0dXJuIGZ1bmN0aW9uIChvYmplY3Q6IGFueSwgcHJvcGVydHlOYW1lOiBhbnkpIHtcbiAgICBjb25zdCBjb2x1bW5zID0gZ2V0TWV0YWRhdGFBcmdzU3RvcmFnZSgpLmNvbHVtbnM7XG4gICAgYWdncmVnYXRlT3JOZXdDb2x1bW4oXG4gICAgICBvYmplY3QuY29uc3RydWN0b3IsXG4gICAgICBwcm9wZXJ0eU5hbWUsXG4gICAgICBjb2x1bW5zLFxuICAgICAgb3B0aW9ucyB8fCB7fSxcbiAgICAgIFwiY3JlYXRlRGF0ZVwiXG4gICAgKTtcbiAgfTtcbn1cbiJdfQ==

package/lib/overrides/CreateDateColumn.d.ts

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

package/lib/overrides/Entity.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity = Entity;
+const typeorm_1 = require("typeorm");
+const ObjectUtils_1 = require("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.
+ */
+function Entity(nameOrOptions, maybeOptions) {
+    const options = (ObjectUtils_1.ObjectUtils.isObject(nameOrOptions)
+        ? nameOrOptions
+        : maybeOptions) || {};
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : options.name;
+    return function (target) {
+        const tables = (0, typeorm_1.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/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/overrides/PrimaryColumn.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimaryColumn = PrimaryColumn;
+const typeorm_1 = require("typeorm");
+const utils_1 = require("./utils.cjs");
+/**
+ * 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.
+ */
+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 typeorm_1.ColumnTypeUndefinedError(object, propertyName);
+        // check if column is not nullable, because we cannot allow a primary key to be nullable
+        if (options.nullable)
+            throw new typeorm_1.PrimaryColumnCannotBeNullableError(object, propertyName);
+        // explicitly set a primary to column options
+        options.primary = true;
+        const columns = (0, typeorm_1.getMetadataArgsStorage)().columns;
+        (0, utils_1.aggregateOrNewColumn)(object.constructor, propertyName, columns, options);
+        if (options.generated) {
+            (0, typeorm_1.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/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/overrides/PrimaryGeneratedColumn.cjs

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrimaryGeneratedColumn = PrimaryGeneratedColumn;
+const ObjectUtils_1 = require("typeorm/util/ObjectUtils");
+const typeorm_1 = require("typeorm");
+const utils_1 = require("./utils.cjs");
+/**
+ * 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.
+ */
+function PrimaryGeneratedColumn(strategyOrOptions, maybeOptions) {
+    // normalize parameters
+    const options = {};
+    let strategy;
+    if (strategyOrOptions) {
+        if (typeof strategyOrOptions === "string")
+            strategy = strategyOrOptions;
+        if (ObjectUtils_1.ObjectUtils.isObject(strategyOrOptions)) {
+            strategy = "increment";
+            Object.assign(options, strategyOrOptions);
+        }
+    }
+    else {
+        strategy = "increment";
+    }
+    if (ObjectUtils_1.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 = (0, typeorm_1.getMetadataArgsStorage)().columns;
+        (0, utils_1.aggregateOrNewColumn)(object.constructor, propertyName, columns, options);
+        // register generated metadata args
+        (0, typeorm_1.getMetadataArgsStorage)().generations.push({
+            target: object.constructor,
+            propertyName: propertyName,
+            strategy: strategy,
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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