14390601550

Committed 10 Apr 2025 09:24PM UTC coverage: 78.699% (+2.2%) from 76.514%

Build # 14390601550

Build Type

Pull #41

github

Committed by

web-flow

Commit Message

Merge a5a669e9c into 0fa3fd4a5

Pull Request Pull Request #41: 2.0.19

Run Details

223 of 283 branches covered (78.8%)

Branch coverage included in aggregate %.

184 of 215 new or added lines in 8 files covered. (85.58%)

3 existing lines in 2 files now uncovered.

926 of 1177 relevant lines covered (78.67%)

19.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.27

/src/utils/sqlUtils.ts

import moment from "moment";
import { AnyColumn, Column, isTable, SQL, sql, StringChunk } from "drizzle-orm";
import { AnyMySqlTable, MySqlCustomColumn } from "drizzle-orm/mysql-core/index";
import { PrimaryKeyBuilder } from "drizzle-orm/mysql-core/primary-keys";
import { AnyIndexBuilder } from "drizzle-orm/mysql-core/indexes";
import { CheckBuilder } from "drizzle-orm/mysql-core/checks";
import { ForeignKeyBuilder } from "drizzle-orm/mysql-core/foreign-keys";
import { UniqueConstraintBuilder } from "drizzle-orm/mysql-core/unique-constraint";
import type { SelectedFields } from "drizzle-orm/mysql-core/query-builders/select.types";
import { MySqlTable } from "drizzle-orm/mysql-core";
import { isSQLWrapper } from "drizzle-orm/sql/sql";

/**
 * Interface representing table metadata information
 */
export interface MetadataInfo {
  /** The name of the table */
  tableName: string;
  /** Record of column names and their corresponding column definitions */
  columns: Record<string, AnyColumn>;
  /** Array of index builders */
  indexes: AnyIndexBuilder[];
  /** Array of check constraint builders */
  checks: CheckBuilder[];
  /** Array of foreign key builders */
  foreignKeys: ForeignKeyBuilder[];
  /** Array of primary key builders */
  primaryKeys: PrimaryKeyBuilder[];
  /** Array of unique constraint builders */
  uniqueConstraints: UniqueConstraintBuilder[];
  /** Array of all extra builders */
  extras: any[];
}

/**
 * Interface for config builder data
 */
interface ConfigBuilderData {
  value?: any;
  [key: string]: any;
}

/**
 * Parses a date string into a Date object using the specified format
 * @param value - The date string to parse
 * @param format - The format to use for parsing
 * @returns Date object
 */
export const parseDateTime = (value: string, format: string): Date => {
  let result: Date;
  const m = moment(value, format, true);
  if (!m.isValid()) {
    const momentDate = moment(value);
    if (momentDate.isValid()) {
      result = momentDate.toDate();
    } else {
      result = new Date(value);
    }
  } else {
    result = m.toDate();
  }
  if (isNaN(result.getTime())) {
    result = new Date(value);
  }
  return result;
};

/**
 * Gets primary keys from the schema.
 * @template T - The type of the table schema
 * @param {T} table - The table schema
 * @returns {[string, AnyColumn][]} Array of primary key name and column pairs
 */
export function getPrimaryKeys<T extends AnyMySqlTable>(table: T): [string, AnyColumn][] {
  const { columns, primaryKeys } = getTableMetadata(table);

  // First try to find primary keys in columns
  const columnPrimaryKeys = Object.entries(columns).filter(([, column]) => column.primary) as [
    string,
    AnyColumn,
  ][];

  if (columnPrimaryKeys.length > 0) {
    return columnPrimaryKeys;
  }

  // If no primary keys found in columns, check primary key builders
  if (Array.isArray(primaryKeys) && primaryKeys.length > 0) {
    // Collect all primary key columns from all primary key builders
    const primaryKeyColumns = new Set<[string, AnyColumn]>();

    primaryKeys.forEach((primaryKeyBuilder) => {
      // Get primary key columns from each builder
      Object.entries(columns)
        .filter(([, column]) => {
          // @ts-ignore - PrimaryKeyBuilder has internal columns property
          return primaryKeyBuilder.columns.includes(column);
        })
        .forEach(([name, column]) => {
          primaryKeyColumns.add([name, column]);
        });
    });

    return Array.from(primaryKeyColumns);
  }

  return [];
}

/**
 * Processes foreign keys from both foreignKeysSymbol and extraSymbol
 * @param table - The table schema
 * @param foreignKeysSymbol - Symbol for foreign keys
 * @param extraSymbol - Symbol for extra configuration
 * @returns Array of foreign key builders
 */
function processForeignKeys(
  table: AnyMySqlTable,
  foreignKeysSymbol: symbol | undefined,
  extraSymbol: symbol | undefined,
): ForeignKeyBuilder[] {
  const foreignKeys: ForeignKeyBuilder[] = [];

  // Process foreign keys from foreignKeysSymbol
  if (foreignKeysSymbol) {
    // @ts-ignore
    const fkArray: any[] = table[foreignKeysSymbol];
    if (fkArray) {
      fkArray.forEach((fk) => {
        if (fk.reference) {
          const item = fk.reference(fk);
          foreignKeys.push(item);
        }
      });
    }
  }

  // Process foreign keys from extraSymbol
  if (extraSymbol) {
    // @ts-ignore
    const extraConfigBuilder = table[extraSymbol];
    if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
      const configBuilderData = extraConfigBuilder(table);
      if (configBuilderData) {
        const configBuilders = Array.isArray(configBuilderData)
          ? configBuilderData
          : Object.values(configBuilderData).map(
              (item) => (item as ConfigBuilderData).value ?? item,
            );

        configBuilders.forEach((builder) => {
          if (!builder?.constructor) return;

          const builderName = builder.constructor.name.toLowerCase();
          if (builderName.includes("foreignkeybuilder")) {
            foreignKeys.push(builder);
          }
        });
      }
    }
  }

  return foreignKeys;
}

/**
 * Extracts table metadata from the schema.
 * @param {AnyMySqlTable} table - The table schema
 * @returns {MetadataInfo} Object containing table metadata
 */
export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
  const symbols = Object.getOwnPropertySymbols(table);
  const nameSymbol = symbols.find((s) => s.toString().includes("Name"));
  const columnsSymbol = symbols.find((s) => s.toString().includes("Columns"));
  const foreignKeysSymbol = symbols.find((s) => s.toString().includes("ForeignKeys)"));
  const extraSymbol = symbols.find((s) => s.toString().includes("ExtraConfigBuilder"));

  // Initialize builders arrays
  const builders = {
    indexes: [] as AnyIndexBuilder[],
    checks: [] as CheckBuilder[],
    foreignKeys: [] as ForeignKeyBuilder[],
    primaryKeys: [] as PrimaryKeyBuilder[],
    uniqueConstraints: [] as UniqueConstraintBuilder[],
    extras: [] as any[],
  };

  // Process foreign keys
  builders.foreignKeys = processForeignKeys(table, foreignKeysSymbol, extraSymbol);

  // Process extra configuration if available
  if (extraSymbol) {
    // @ts-ignore
    const extraConfigBuilder = table[extraSymbol];
    if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
      const configBuilderData = extraConfigBuilder(table);
      if (configBuilderData) {
        // Convert configBuilderData to array if it's an object
        const configBuilders = Array.isArray(configBuilderData)
          ? configBuilderData
          : Object.values(configBuilderData).map(
              (item) => (item as ConfigBuilderData).value ?? item,
            );

        // Process each builder
        configBuilders.forEach((builder) => {
          if (!builder?.constructor) return;

          const builderName = builder.constructor.name.toLowerCase();

          // Map builder types to their corresponding arrays
          const builderMap = {
            indexbuilder: builders.indexes,
            checkbuilder: builders.checks,
            primarykeybuilder: builders.primaryKeys,
            uniqueconstraintbuilder: builders.uniqueConstraints,
          };

          // Add builder to appropriate array if it matches any type
          for (const [type, array] of Object.entries(builderMap)) {
            if (builderName.includes(type)) {
              array.push(builder);
              break;
            }
          }

          // Always add to extras array
          builders.extras.push(builder);
        });
      }
    }
  }

  return {
    tableName: nameSymbol ? (table as any)[nameSymbol] : "",
    columns: columnsSymbol ? ((table as any)[columnsSymbol] as Record<string, AnyColumn>) : {},
    ...builders,
  };
}

/**
 * Generates SQL statements to drop tables
 * @param tables - Array of table names
 * @returns Array of SQL statements for dropping tables
 */
export function generateDropTableStatements(tables: string[]): string[] {
  const dropStatements: string[] = [];

  tables.forEach((tableName) => {
    dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);
  });

  return dropStatements;
}

type AliasColumnMap = Record<string, AnyColumn>;

function mapSelectTableToAlias(
  table: MySqlTable,
  uniqPrefix: string,
  aliasMap: AliasColumnMap,
): any {
  const { columns, tableName } = getTableMetadata(table);
  const selectionsTableFields: Record<string, unknown> = {};
  Object.keys(columns).forEach((name) => {
    const column = columns[name] as AnyColumn;
    const uniqName = `a_${uniqPrefix}_${tableName}_${column.name}`.toLowerCase();
    const fieldAlias = sql.raw(uniqName);
    selectionsTableFields[name] = sql`${column} as \`${fieldAlias}\``;
    aliasMap[uniqName] = column;
  });
  return selectionsTableFields;
}

function isDrizzleColumn(column: any): boolean {
  return column && typeof column === "object" && "table" in column;
}

export function mapSelectAllFieldsToAlias(
  selections: any,
  name: string,
  uniqName: string,
  fields: any,
  aliasMap: AliasColumnMap,
): any {
  if (isTable(fields)) {
    selections[name] = mapSelectTableToAlias(fields as MySqlTable, uniqName, aliasMap);
  } else if (isDrizzleColumn(fields)) {
    const column = fields as Column;
    const uniqAliasName = `a_${uniqName}_${column.name}`.toLowerCase();
    let aliasName = sql.raw(uniqAliasName);
    selections[name] = sql`${column} as \`${aliasName}\``;
    aliasMap[uniqAliasName] = column;
  } else if (isSQLWrapper(fields)) {
    selections[name] = fields;
  } else {
    const innerSelections: any = {};
    Object.entries(fields).forEach(([iname, ifields]) => {
      mapSelectAllFieldsToAlias(innerSelections, iname, `${uniqName}_${iname}`, ifields, aliasMap);
    });
    selections[name] = innerSelections;
  }
  return selections;
}
export function mapSelectFieldsWithAlias<TSelection extends SelectedFields>(
  fields: TSelection,
): { selections: TSelection; aliasMap: AliasColumnMap } {
  if (!fields) {
    throw new Error("fields is empty");
  }
  const aliasMap: AliasColumnMap = {};
  const selections: any = {};
  Object.entries(fields).forEach(([name, fields]) => {
    mapSelectAllFieldsToAlias(selections, name, name, fields, aliasMap);
  });
  return { selections, aliasMap };
}

function getAliasFromDrizzleAlias(value: unknown): string | undefined {
  const isSQL =
    value !== null && typeof value === "object" && isSQLWrapper(value) && "queryChunks" in value;
  if (isSQL) {
    const sql = value as SQL;
    const queryChunks = sql.queryChunks;
    if (queryChunks.length > 3) {
      const aliasNameChunk = queryChunks[queryChunks.length - 2];
      if (isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {
        const aliasNameChunkSql = aliasNameChunk as SQL;
        if (aliasNameChunkSql.queryChunks?.length === 1 && aliasNameChunkSql.queryChunks[0]) {
          const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];
          if ("value" in queryChunksStringChunc) {
            const values = (queryChunksStringChunc as StringChunk).value;
            if (values && values.length === 1) {
              return values[0];
            }
          }
        }
      }
    }
  }
  return undefined;
}

function transformValue(
  value: unknown,
  alias: string,
  aliasMap: Record<string, AnyColumn>,
): unknown {
  const column = aliasMap[alias];
  if (!column) return value;

  let customColumn = column as MySqlCustomColumn<any>;
  // @ts-ignore
  const fromDriver = customColumn?.mapFrom;
  if (fromDriver && value !== null && value !== undefined) {
    return fromDriver(value);
  }
  return value;
}

function transformObject(
  obj: Record<string, unknown>,
  selections: Record<string, unknown>,
  aliasMap: Record<string, AnyColumn>,
): Record<string, unknown> {
  const result: Record<string, unknown> = {};

  for (const [key, value] of Object.entries(obj)) {
    const selection = selections[key];
    const alias = getAliasFromDrizzleAlias(selection);
    if (alias && aliasMap[alias]) {
      result[key] = transformValue(value, alias, aliasMap);
    } else if (selection && typeof selection === "object" && !isSQLWrapper(selection)) {
      result[key] = transformObject(
        value as Record<string, unknown>,
        selection as Record<string, unknown>,
        aliasMap,
      );
    } else {
      result[key] = value;
    }
  }

  return result;
}

export function applyFromDriverTransform<T, TSelection>(
  rows: T[],
  selections: TSelection,
  aliasMap: Record<string, AnyColumn>,
): T[] {
  return rows.map((row) => {
    const transformed = transformObject(
      row as Record<string, unknown>,
      selections as Record<string, unknown>,
      aliasMap,
    ) as Record<string, unknown>;

    return processNullBranches(transformed) as unknown as T;
  });
}

function processNullBranches(obj: Record<string, unknown>): Record<string, unknown> | null {
  if (obj === null || typeof obj !== "object") {
    return obj;
  }

  // Skip built-in objects like Date, Array, etc.
  if (obj.constructor && obj.constructor.name !== "Object") {
    return obj;
  }

  const result: Record<string, unknown> = {};
  let allNull = true;

  for (const [key, value] of Object.entries(obj)) {
    if (value === null || value === undefined) {
      result[key] = null;
      continue;
    }

    if (typeof value === "object") {
      const processed = processNullBranches(value as Record<string, unknown>);
      result[key] = processed;
      if (processed !== null) {
        allNull = false;
      }
    } else {
      result[key] = value;
      allNull = false;
    }
  }

  return allNull ? null : result;
}

1	import moment from "moment";	2✔
2	import { AnyColumn, Column, isTable, SQL, sql, StringChunk } from "drizzle-orm";	2✔
3	import { AnyMySqlTable, MySqlCustomColumn } from "drizzle-orm/mysql-core/index";
4	import { PrimaryKeyBuilder } from "drizzle-orm/mysql-core/primary-keys";
5	import { AnyIndexBuilder } from "drizzle-orm/mysql-core/indexes";
6	import { CheckBuilder } from "drizzle-orm/mysql-core/checks";
7	import { ForeignKeyBuilder } from "drizzle-orm/mysql-core/foreign-keys";
8	import { UniqueConstraintBuilder } from "drizzle-orm/mysql-core/unique-constraint";
9	import type { SelectedFields } from "drizzle-orm/mysql-core/query-builders/select.types";
10	import { MySqlTable } from "drizzle-orm/mysql-core";
11	import { isSQLWrapper } from "drizzle-orm/sql/sql";	2✔
12
13	/**
14	* Interface representing table metadata information
15	*/
16	export interface MetadataInfo {
17	/** The name of the table */
18	tableName: string;
19	/** Record of column names and their corresponding column definitions */
20	columns: Record<string, AnyColumn>;
21	/** Array of index builders */
22	indexes: AnyIndexBuilder[];
23	/** Array of check constraint builders */
24	checks: CheckBuilder[];
25	/** Array of foreign key builders */
26	foreignKeys: ForeignKeyBuilder[];
27	/** Array of primary key builders */
28	primaryKeys: PrimaryKeyBuilder[];
29	/** Array of unique constraint builders */
30	uniqueConstraints: UniqueConstraintBuilder[];
31	/** Array of all extra builders */
32	extras: any[];
33	}
34
35	/**
36	* Interface for config builder data
37	*/
38	interface ConfigBuilderData {
39	value?: any;
40	[key: string]: any;
41	}
42
43	/**
44	* Parses a date string into a Date object using the specified format
45	* @param value - The date string to parse
46	* @param format - The format to use for parsing
47	* @returns Date object
48	*/
49	export const parseDateTime = (value: string, format: string): Date => {	2✔
50	let result: Date;	18✔
51	const m = moment(value, format, true);	18✔
52	if (!m.isValid()) {	18✔
53	const momentDate = moment(value);	8✔
54	if (momentDate.isValid()) {	8✔
55	result = momentDate.toDate();	8✔
56	} else {	8!
57	result = new Date(value);	×
58	}	×
59	} else {	18✔
60	result = m.toDate();	10✔
61	}	10✔
62	if (isNaN(result.getTime())) {	18!
63	result = new Date(value);	×
64	}	×
65	return result;	18✔
66	};	18✔
67
68	/**
69	* Gets primary keys from the schema.
70	* @template T - The type of the table schema
71	* @param {T} table - The table schema
72	* @returns {[string, AnyColumn][]} Array of primary key name and column pairs
73	*/
74	export function getPrimaryKeys<T extends AnyMySqlTable>(table: T): [string, AnyColumn][] {	2✔
75	const { columns, primaryKeys } = getTableMetadata(table);	16✔
76
77	// First try to find primary keys in columns
78	const columnPrimaryKeys = Object.entries(columns).filter(([, column]) => column.primary) as [	16✔
79	string,
80	AnyColumn,
81	][];
82
83	if (columnPrimaryKeys.length > 0) {	16✔
84	return columnPrimaryKeys;	12✔
85	}	12✔
86
87	// If no primary keys found in columns, check primary key builders
88	if (Array.isArray(primaryKeys) && primaryKeys.length > 0) {	16✔
89	// Collect all primary key columns from all primary key builders
90	const primaryKeyColumns = new Set<[string, AnyColumn]>();	4✔
91
92	primaryKeys.forEach((primaryKeyBuilder) => {	4✔
93	// Get primary key columns from each builder
94	Object.entries(columns)	4✔
95	.filter(([, column]) => {	4✔
96	// @ts-ignore - PrimaryKeyBuilder has internal columns property
97	return primaryKeyBuilder.columns.includes(column);	8✔
98	})	4✔
99	.forEach(([name, column]) => {	4✔
100	primaryKeyColumns.add([name, column]);	4✔
101	});	4✔
102	});	4✔
103
104	return Array.from(primaryKeyColumns);	4✔
105	}	4!
106
107	return [];	×
108	}	×
109
110	/**
111	* Processes foreign keys from both foreignKeysSymbol and extraSymbol
112	* @param table - The table schema
113	* @param foreignKeysSymbol - Symbol for foreign keys
114	* @param extraSymbol - Symbol for extra configuration
115	* @returns Array of foreign key builders
116	*/
117	function processForeignKeys(	52✔
118	table: AnyMySqlTable,	52✔
119	foreignKeysSymbol: symbol \| undefined,	52✔
120	extraSymbol: symbol \| undefined,	52✔
121	): ForeignKeyBuilder[] {	52✔
122	const foreignKeys: ForeignKeyBuilder[] = [];	52✔
123
124	// Process foreign keys from foreignKeysSymbol
125	if (foreignKeysSymbol) {	52✔
126	// @ts-ignore
127	const fkArray: any[] = table[foreignKeysSymbol];	52✔
128	if (fkArray) {	52✔
129	fkArray.forEach((fk) => {	52✔
130	if (fk.reference) {	×
131	const item = fk.reference(fk);	×
132	foreignKeys.push(item);	×
133	}	×
134	});	52✔
135	}	52✔
136	}	52✔
137
138	// Process foreign keys from extraSymbol
139	if (extraSymbol) {	52✔
140	// @ts-ignore
141	const extraConfigBuilder = table[extraSymbol];	52✔
142	if (extraConfigBuilder && typeof extraConfigBuilder === "function") {	52✔
143	const configBuilderData = extraConfigBuilder(table);	20✔
144	if (configBuilderData) {	20✔
145	const configBuilders = Array.isArray(configBuilderData)	20✔
146	? configBuilderData	20!
147	: Object.values(configBuilderData).map(	×
NEW 148	(item) => (item as ConfigBuilderData).value ?? item,	×
149	);	×
150
151	configBuilders.forEach((builder) => {	20✔
152	if (!builder?.constructor) return;	20!
153
154	const builderName = builder.constructor.name.toLowerCase();	20✔
155	if (builderName.includes("foreignkeybuilder")) {	20!
156	foreignKeys.push(builder);	×
157	}	×
158	});	20✔
159	}	20✔
160	}	20✔
161	}	52✔
162
163	return foreignKeys;	52✔
164	}	52✔
165
166	/**
167	* Extracts table metadata from the schema.
168	* @param {AnyMySqlTable} table - The table schema
169	* @returns {MetadataInfo} Object containing table metadata
170	*/
171	export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {	2✔
172	const symbols = Object.getOwnPropertySymbols(table);	52✔
173	const nameSymbol = symbols.find((s) => s.toString().includes("Name"));	52✔
174	const columnsSymbol = symbols.find((s) => s.toString().includes("Columns"));	52✔
175	const foreignKeysSymbol = symbols.find((s) => s.toString().includes("ForeignKeys)"));	52✔
176	const extraSymbol = symbols.find((s) => s.toString().includes("ExtraConfigBuilder"));	52✔
177
178	// Initialize builders arrays
179	const builders = {	52✔
180	indexes: [] as AnyIndexBuilder[],	52✔
181	checks: [] as CheckBuilder[],	52✔
182	foreignKeys: [] as ForeignKeyBuilder[],	52✔
183	primaryKeys: [] as PrimaryKeyBuilder[],	52✔
184	uniqueConstraints: [] as UniqueConstraintBuilder[],	52✔
185	extras: [] as any[],	52✔
186	};	52✔
187
188	// Process foreign keys
189	builders.foreignKeys = processForeignKeys(table, foreignKeysSymbol, extraSymbol);	52✔
190
191	// Process extra configuration if available
192	if (extraSymbol) {	52✔
193	// @ts-ignore
194	const extraConfigBuilder = table[extraSymbol];	52✔
195	if (extraConfigBuilder && typeof extraConfigBuilder === "function") {	52✔
196	const configBuilderData = extraConfigBuilder(table);	20✔
197	if (configBuilderData) {	20✔
198	// Convert configBuilderData to array if it's an object
199	const configBuilders = Array.isArray(configBuilderData)	20✔
200	? configBuilderData	20!
201	: Object.values(configBuilderData).map(	×
NEW 202	(item) => (item as ConfigBuilderData).value ?? item,	×
203	);	×
204
205	// Process each builder
206	configBuilders.forEach((builder) => {	20✔
207	if (!builder?.constructor) return;	20!
208
209	const builderName = builder.constructor.name.toLowerCase();	20✔
210
211	// Map builder types to their corresponding arrays
212	const builderMap = {	20✔
213	indexbuilder: builders.indexes,	20✔
214	checkbuilder: builders.checks,	20✔
215	primarykeybuilder: builders.primaryKeys,	20✔
216	uniqueconstraintbuilder: builders.uniqueConstraints,	20✔
217	};	20✔
218
219	// Add builder to appropriate array if it matches any type
220	for (const [type, array] of Object.entries(builderMap)) {	20✔
221	if (builderName.includes(type)) {	60✔
222	array.push(builder);	20✔
223	break;	20✔
224	}	20✔
225	}	60✔
226
227	// Always add to extras array
228	builders.extras.push(builder);	20✔
229	});	20✔
230	}	20✔
231	}	20✔
232	}	52✔
233
234	return {	52✔
235	tableName: nameSymbol ? (table as any)[nameSymbol] : "",	52!
236	columns: columnsSymbol ? ((table as any)[columnsSymbol] as Record<string, AnyColumn>) : {},	52!
237	...builders,	52✔
238	};	52✔
239	}	52✔
240
241	/**
242	* Generates SQL statements to drop tables
243	* @param tables - Array of table names
244	* @returns Array of SQL statements for dropping tables
245	*/
246	export function generateDropTableStatements(tables: string[]): string[] {	2✔
247	const dropStatements: string[] = [];	×
248
NEW 249	tables.forEach((tableName) => {	×
NEW 250	dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);	×
UNCOV 251	});	×
252
UNCOV 253	return dropStatements;	×
254	}	×
255
256	type AliasColumnMap = Record<string, AnyColumn>;
257
258	function mapSelectTableToAlias(	12✔
259	table: MySqlTable,	12✔
260	uniqPrefix: string,	12✔
261	aliasMap: AliasColumnMap,	12✔
262	): any {	12✔
263	const { columns, tableName } = getTableMetadata(table);	12✔
264	const selectionsTableFields: Record<string, unknown> = {};	12✔
265	Object.keys(columns).forEach((name) => {	12✔
266	const column = columns[name] as AnyColumn;	46✔
267	const uniqName = `a_${uniqPrefix}_${tableName}_${column.name}`.toLowerCase();	46✔
268	const fieldAlias = sql.raw(uniqName);	46✔
269	selectionsTableFields[name] = sql`${column} as \`${fieldAlias}\``;	46✔
270	aliasMap[uniqName] = column;	46✔
271	});	12✔
272	return selectionsTableFields;	12✔
273	}	12✔
274
275	function isDrizzleColumn(column: any): boolean {	52✔
276	return column && typeof column === "object" && "table" in column;	52✔
277	}	52✔
278
279	export function mapSelectAllFieldsToAlias(	2✔
280	selections: any,	64✔
281	name: string,	64✔
282	uniqName: string,	64✔
283	fields: any,	64✔
284	aliasMap: AliasColumnMap,	64✔
285	): any {	64✔
286	if (isTable(fields)) {	64✔
287	selections[name] = mapSelectTableToAlias(fields as MySqlTable, uniqName, aliasMap);	12✔
288	} else if (isDrizzleColumn(fields)) {	64✔
289	const column = fields as Column;	28✔
290	const uniqAliasName = `a_${uniqName}_${column.name}`.toLowerCase();	28✔
291	let aliasName = sql.raw(uniqAliasName);	28✔
292	selections[name] = sql`${column} as \`${aliasName}\``;	28✔
293	aliasMap[uniqAliasName] = column;	28✔
294	} else if (isSQLWrapper(fields)) {	52✔
295	selections[name] = fields;	10✔
296	} else {	24✔
297	const innerSelections: any = {};	14✔
298	Object.entries(fields).forEach(([iname, ifields]) => {	14✔
299	mapSelectAllFieldsToAlias(innerSelections, iname, `${uniqName}_${iname}`, ifields, aliasMap);	28✔
300	});	14✔
301	selections[name] = innerSelections;	14✔
302	}	14✔
303	return selections;	64✔
304	}	64✔
305	export function mapSelectFieldsWithAlias<TSelection extends SelectedFields>(	2✔
306	fields: TSelection,	12✔
307	): { selections: TSelection; aliasMap: AliasColumnMap } {	12✔
308	if (!fields) {	12!
309	throw new Error("fields is empty");	×
310	}	×
311	const aliasMap: AliasColumnMap = {};	12✔
312	const selections: any = {};	12✔
313	Object.entries(fields).forEach(([name, fields]) => {	12✔
314	mapSelectAllFieldsToAlias(selections, name, name, fields, aliasMap);	36✔
315	});	12✔
316	return { selections, aliasMap };	12✔
317	}	12✔
318
319	function getAliasFromDrizzleAlias(value: unknown): string \| undefined {	220✔
320	const isSQL =	220✔
321	value !== null && typeof value === "object" && isSQLWrapper(value) && "queryChunks" in value;	220✔
322	if (isSQL) {	220✔
323	const sql = value as SQL;	168✔
324	const queryChunks = sql.queryChunks;	168✔
325	if (queryChunks.length > 3) {	168✔
326	const aliasNameChunk = queryChunks[queryChunks.length - 2];	148✔
327	if (isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {	148✔
328	const aliasNameChunkSql = aliasNameChunk as SQL;	148✔
329	if (aliasNameChunkSql.queryChunks?.length === 1 && aliasNameChunkSql.queryChunks[0]) {	148✔
330	const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];	148✔
331	if ("value" in queryChunksStringChunc) {	148✔
332	const values = (queryChunksStringChunc as StringChunk).value;	148✔
333	if (values && values.length === 1) {	148✔
334	return values[0];	148✔
335	}	148✔
336	}	148✔
337	}	148✔
338	}	148✔
339	}	148✔
340	}	168✔
341	return undefined;	72✔
342	}	72✔
343
344	function transformValue(	148✔
345	value: unknown,	148✔
346	alias: string,	148✔
347	aliasMap: Record<string, AnyColumn>,	148✔
348	): unknown {	148✔
349	const column = aliasMap[alias];	148✔
350	if (!column) return value;	148!
351
352	let customColumn = column as MySqlCustomColumn<any>;	148✔
353	// @ts-ignore
354	const fromDriver = customColumn?.mapFrom;	148✔
355	if (fromDriver && value !== null && value !== undefined) {	148✔
356	return fromDriver(value);	28✔
357	}	28✔
358	return value;	120✔
359	}	120✔
360
361	function transformObject(	76✔
362	obj: Record<string, unknown>,	76✔
363	selections: Record<string, unknown>,	76✔
364	aliasMap: Record<string, AnyColumn>,	76✔
365	): Record<string, unknown> {	76✔
366	const result: Record<string, unknown> = {};	76✔
367
368	for (const [key, value] of Object.entries(obj)) {	76✔
369	const selection = selections[key];	220✔
370	const alias = getAliasFromDrizzleAlias(selection);	220✔
371	if (alias && aliasMap[alias]) {	220✔
372	result[key] = transformValue(value, alias, aliasMap);	148✔
373	} else if (selection && typeof selection === "object" && !isSQLWrapper(selection)) {	220✔
374	result[key] = transformObject(	52✔
375	value as Record<string, unknown>,	52✔
376	selection as Record<string, unknown>,	52✔
377	aliasMap,	52✔
378	);	52✔
379	} else {	72✔
380	result[key] = value;	20✔
381	}	20✔
382	}	220✔
383
384	return result;	76✔
385	}	76✔
386
387	export function applyFromDriverTransform<T, TSelection>(	2✔
388	rows: T[],	12✔
389	selections: TSelection,	12✔
390	aliasMap: Record<string, AnyColumn>,	12✔
391	): T[] {	12✔
392	return rows.map((row) => {	12✔
393	const transformed = transformObject(	24✔
394	row as Record<string, unknown>,	24✔
395	selections as Record<string, unknown>,	24✔
396	aliasMap,	24✔
397	) as Record<string, unknown>;	24✔
398
399	return processNullBranches(transformed) as unknown as T;	24✔
400	});	12✔
401	}	12✔
402
403	function processNullBranches(obj: Record<string, unknown>): Record<string, unknown> \| null {	84✔
404	if (obj === null \|\| typeof obj !== "object") {	84!
405	return obj;	×
406	}	×
407
408	// Skip built-in objects like Date, Array, etc.
409	if (obj.constructor && obj.constructor.name !== "Object") {	84✔
410	return obj;	8✔
411	}	8✔
412
413	const result: Record<string, unknown> = {};	76✔
414	let allNull = true;	76✔
415
416	for (const [key, value] of Object.entries(obj)) {	84✔
417	if (value === null \|\| value === undefined) {	220✔
418	result[key] = null;	10✔
419	continue;	10✔
420	}	10✔
421
422	if (typeof value === "object") {	220✔
423	const processed = processNullBranches(value as Record<string, unknown>);	60✔
424	result[key] = processed;	60✔
425	if (processed !== null) {	60✔
426	allNull = false;	58✔
427	}	58✔
428	} else {	220✔
429	result[key] = value;	150✔
430	allNull = false;	150✔
431	}	150✔
432	}	220✔
433
434	return allNull ? null : result;	84✔
435	}	84✔

vzakharchenko / forge-sql-orm / 14390601550

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous