typeorm-extensions 2.2.0-rc.6 → 2.2.0-rc.7

package/dist/utils/table.utils.d.ts

@@ -74,17 +74,7 @@ export type TableHelperTimeZone<T> = string | {
 /** The units of PostgreSQL's `date_trunc`. */
 export type DateTruncUnit = 'microseconds' | 'milliseconds' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year' | 'decade' | 'century' | 'millennium';
 export type JsonFieldRest<V> = [NonNullable<V>] extends [Record<string, unknown>] ? JsonFieldTuple<NonNullable<V>> : string[];
-/**
- * Creates a type-safe SQL helper for building column references, WHERE expressions,
- * JOIN clauses, and JSONB accessors for a given entity type.
- *
- * @example
- * const t = tableHelper<UserEntity>('user');
- * t.column('email')              // → "user"."email"
- * t.where('id', '= :id')        // → "user"."id" = :id
- * t.jsonColumn('metadata', '->>', 'role')  // → "user"."metadata" ->> 'role'
- */
-export declare const tableHelper: <T extends ObjectLiteral>(alias?: string, options?: TableHelperOptions) => {
+declare const createTableHelper: <T extends ObjectLiteral>(alias?: string, options?: TableHelperOptions, databaseNames?: ReadonlyMap<string, string>) => {
     alias: string | undefined;
     /**
      * Returns a quoted SQL column identifier, e.g. `"alias"."column"`. The column is always quoted as one
@@ -193,4 +183,30 @@ export declare const tableHelper: <T extends ObjectLiteral>(alias?: string, opti
      */
     dateTrunc(unit: DateTruncUnit, value: TableHelperExpression<T>, timeZone?: TableHelperTimeZone<T> | undefined): string;
 };
+type TableHelperMemberName = keyof ReturnType<typeof createTableHelper>;
+/**
+ * The helper `tableHelper` returns: its methods, and each column of the table as a read-only property,
+ * `t.email` for `t.column('email')`. A column named like a member (`alias`, `count`, …) is the member there.
+ */
+export type TableHelper<T extends ObjectLiteral> = ReturnType<typeof createTableHelper<T>> & {
+    readonly [K in Exclude<ColumnName<T>, TableHelperMemberName>]: string;
+};
+/** An entity class, abstract ones included. */
+export type EntityClass<T> = abstract new (...args: never[]) => T;
+/**
+ * Creates a type-safe SQL helper for building column references, WHERE expressions,
+ * JOIN clauses, and JSONB accessors for a given entity type.
+ *
+ * Given the entity class, it takes property names and writes the column names the entity maps them to:
+ * `tableHelper(UserEntity, 'user').adminEmail` is `"user"."email"` for `@Column({ name: 'email' }) adminEmail`.
+ *
+ * @example
+ * const t = tableHelper<UserEntity>('user');
+ * t.column('email')              // → "user"."email"
+ * t.email                        // → "user"."email", the same
+ * t.where('id', '= :id')        // → "user"."id" = :id
+ * t.jsonColumn('metadata', '->>', 'role')  // → "user"."metadata" ->> 'role'
+ */
+export declare function tableHelper<T extends ObjectLiteral>(entity: EntityClass<T>, alias?: string, options?: TableHelperOptions): TableHelper<T>;
+export declare function tableHelper<T extends ObjectLiteral>(alias?: string, options?: TableHelperOptions): TableHelper<T>;
 export {};

package/dist/utils/table.utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tableHelper = void 0;
+const typeorm_1 = require("typeorm");
 const sql_utils_1 = require("./sql.utils");
 const json_path_utils_1 = require("./json-path.utils");
 /**
@@ -102,26 +103,17 @@ function jsonFunctions(driver, jsonb) {
 }
 // MySQL reads a backslash in a string as an escape (unless NO_BACKSLASH_ESCAPES): `\'` would end the literal
 const sqlString = (value, driver) => `'${((0, sql_utils_1.isMysqlLikeDriver)(driver) ? value.replace(/\\/g, '\\\\') : value).replace(/'/g, "''")}'`;
-/**
- * Creates a type-safe SQL helper for building column references, WHERE expressions,
- * JOIN clauses, and JSONB accessors for a given entity type.
- *
- * @example
- * const t = tableHelper<UserEntity>('user');
- * t.column('email')              // → "user"."email"
- * t.where('id', '= :id')        // → "user"."id" = :id
- * t.jsonColumn('metadata', '->>', 'role')  // → "user"."metadata" ->> 'role'
- */
-const tableHelper = (alias, options = {}) => ({
+const createTableHelper = (alias, options = {}, databaseNames) => ({
     alias,
     /**
      * Returns a quoted SQL column identifier, e.g. `"alias"."column"`. The column is always quoted as one
      * identifier, so names with other characters work too: `"user"."first-name"`.
      */
     column(columnName, alias) {
+        var _a;
         const { useQuotes = true, driver } = options;
         const tableAlias = alias !== null && alias !== void 0 ? alias : this.alias;
-        const column = String(columnName);
+        const column = (_a = databaseNames === null || databaseNames === void 0 ? void 0 : databaseNames.get(String(columnName))) !== null && _a !== void 0 ? _a : String(columnName);
         if (!useQuotes) {
             return [tableAlias, column].filter(Boolean).join('.');
         }
@@ -316,4 +308,49 @@ const tableHelper = (alias, options = {}) => ({
         return `date_trunc('${unit}', ${toExpression(value, toColumn)}${zone})`;
     }
 });
+// keys that JavaScript, Node and test tools read on any object (await, JSON.stringify, util.inspect, Jest): they
+// must stay undefined, as must symbols. The members of Object.prototype are in the target already
+const PROTOCOL_KEYS = new Set(['then', 'toJSON', 'inspect', 'asymmetricMatch', '$$typeof', 'nodeType']);
+const columnAccess = {
+    get(target, key, receiver) {
+        if (typeof key === 'symbol' || key in target || PROTOCOL_KEYS.has(key)) {
+            return Reflect.get(target, key, receiver);
+        }
+        return target.column(key);
+    },
+};
+const databaseNamesByEntity = new WeakMap();
+// The names set with `@Column({ name })` on the class or a parent, the nearest declaration winning. Every other
+// column keeps its property name, as under TypeORM's default naming strategy. Columns of embedded entities are not read
+const databaseColumnNames = (entity) => {
+    var _a;
+    const cached = databaseNamesByEntity.get(entity);
+    if (cached) {
+        return cached;
+    }
+    const lineage = [];
+    for (let target = entity; typeof target === 'function' && target !== Function.prototype; target = Object.getPrototypeOf(target)) {
+        lineage.push(target);
+    }
+    const names = new Map();
+    const depths = new Map();
+    for (const { target, propertyName, options } of (0, typeorm_1.getMetadataArgsStorage)().columns) {
+        const depth = lineage.indexOf(target);
+        if (depth !== -1 && options.name && depth < ((_a = depths.get(propertyName)) !== null && _a !== void 0 ? _a : Infinity)) {
+            names.set(propertyName, options.name);
+            depths.set(propertyName, depth);
+        }
+    }
+    databaseNamesByEntity.set(entity, names);
+    return names;
+};
+function tableHelper(entityOrAlias, aliasOrOptions, entityOptions) {
+    if (entityOrAlias === undefined && typeof aliasOrOptions === 'string') {
+        throw new TypeError(`tableHelper(entity, '${aliasOrOptions}'): the entity class is undefined, as a circular import leaves it at module load. Create the helper where it is used`);
+    }
+    const helper = typeof entityOrAlias === 'function'
+        ? createTableHelper(aliasOrOptions, entityOptions, databaseColumnNames(entityOrAlias))
+        : createTableHelper(entityOrAlias, aliasOrOptions);
+    return new Proxy(helper, columnAccess);
+}
 exports.tableHelper = tableHelper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typeorm-extensions",
-  "version": "2.2.0-rc.6",
+  "version": "2.2.0-rc.7",
   "description": "typeorm commonly used extensions",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "scripts": {
     "build": "tsc -p .",
     "lint": "eslint . --ext .ts",
-    "test:types": "tsc -p test/types && tsc -p test/types/tsconfig.loose.json"
+    "test:types": "tsc -p test/types && tsc -p test/types/tsconfig.loose.json && tsc -p test/types/typed-imports && tsc -p test/types/typed-imports/tsconfig.loose.json"
   },
   "keywords": [
     "typeorm",