• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

vzakharchenko / forge-sql-orm / 17155561031

22 Aug 2025 12:41PM UTC coverage: 86.696% (+0.03%) from 86.671%
17155561031

push

github

vzakharchenko
update dependencies
added trigger for dropped only tables

264 of 326 branches covered (80.98%)

Branch coverage included in aggregate %.

13 of 15 new or added lines in 3 files covered. (86.67%)

1 existing line in 1 file now uncovered.

1098 of 1245 relevant lines covered (88.19%)

11.16 hits per line

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

90.31
/src/utils/sqlUtils.ts
1
import moment from "moment";
1✔
2
import { AnyColumn, Column, isTable, SQL, sql, StringChunk } from "drizzle-orm";
1✔
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";
1✔
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 => {
1✔
50
  let result: Date;
9✔
51
  const m = moment(value, format, true);
9✔
52
  if (!m.isValid()) {
9✔
53
    const momentDate = moment(value);
4✔
54
    if (momentDate.isValid()) {
4✔
55
      result = momentDate.toDate();
4✔
56
    } else {
4!
57
      result = new Date(value);
×
58
    }
×
59
  } else {
9✔
60
    result = m.toDate();
5✔
61
  }
5✔
62
  if (isNaN(result.getTime())) {
9!
63
    result = new Date(value);
×
64
  }
×
65
  return result;
9✔
66
};
9✔
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][] {
1✔
75
  const { columns, primaryKeys } = getTableMetadata(table);
14✔
76

77
  // First try to find primary keys in columns
78
  const columnPrimaryKeys = Object.entries(columns).filter(([, column]) => column.primary) as [
14✔
79
    string,
80
    AnyColumn,
81
  ][];
82

83
  if (columnPrimaryKeys.length > 0) {
14✔
84
    return columnPrimaryKeys;
10✔
85
  }
10✔
86

87
  // If no primary keys found in columns, check primary key builders
88
  if (Array.isArray(primaryKeys) && primaryKeys.length > 0) {
14✔
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(
41✔
118
  table: AnyMySqlTable,
41✔
119
  foreignKeysSymbol: symbol | undefined,
41✔
120
  extraSymbol: symbol | undefined,
41✔
121
): ForeignKeyBuilder[] {
41✔
122
  const foreignKeys: ForeignKeyBuilder[] = [];
41✔
123

124
  // Process foreign keys from foreignKeysSymbol
125
  if (foreignKeysSymbol) {
41✔
126
    // @ts-ignore
127
    const fkArray: any[] = table[foreignKeysSymbol];
41✔
128
    if (fkArray) {
41✔
129
      fkArray.forEach((fk) => {
41✔
130
        if (fk.reference) {
×
131
          const item = fk.reference(fk);
×
132
          foreignKeys.push(item);
×
133
        }
×
134
      });
41✔
135
    }
41✔
136
  }
41✔
137

138
  // Process foreign keys from extraSymbol
139
  if (extraSymbol) {
41✔
140
    // @ts-ignore
141
    const extraConfigBuilder = table[extraSymbol];
41✔
142
    if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
41✔
143
      const configBuilderData = extraConfigBuilder(table);
16✔
144
      if (configBuilderData) {
16✔
145
        const configBuilders = Array.isArray(configBuilderData)
16✔
146
          ? configBuilderData
16!
147
          : Object.values(configBuilderData).map(
×
148
              (item) => (item as ConfigBuilderData).value ?? item,
×
149
            );
×
150

151
        configBuilders.forEach((builder) => {
16✔
152
          if (!builder?.constructor) return;
16!
153

154
          const builderName = builder.constructor.name.toLowerCase();
16✔
155
          if (builderName.includes("foreignkeybuilder")) {
16!
156
            foreignKeys.push(builder);
×
157
          }
×
158
        });
16✔
159
      }
16✔
160
    }
16✔
161
  }
41✔
162

163
  return foreignKeys;
41✔
164
}
41✔
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 {
1✔
172
  const symbols = Object.getOwnPropertySymbols(table);
41✔
173
  const nameSymbol = symbols.find((s) => s.toString().includes("Name"));
41✔
174
  const columnsSymbol = symbols.find((s) => s.toString().includes("Columns"));
41✔
175
  const foreignKeysSymbol = symbols.find((s) => s.toString().includes("ForeignKeys)"));
41✔
176
  const extraSymbol = symbols.find((s) => s.toString().includes("ExtraConfigBuilder"));
41✔
177

178
  // Initialize builders arrays
179
  const builders = {
41✔
180
    indexes: [] as AnyIndexBuilder[],
41✔
181
    checks: [] as CheckBuilder[],
41✔
182
    foreignKeys: [] as ForeignKeyBuilder[],
41✔
183
    primaryKeys: [] as PrimaryKeyBuilder[],
41✔
184
    uniqueConstraints: [] as UniqueConstraintBuilder[],
41✔
185
    extras: [] as any[],
41✔
186
  };
41✔
187

188
  // Process foreign keys
189
  builders.foreignKeys = processForeignKeys(table, foreignKeysSymbol, extraSymbol);
41✔
190

191
  // Process extra configuration if available
192
  if (extraSymbol) {
41✔
193
    // @ts-ignore
194
    const extraConfigBuilder = table[extraSymbol];
41✔
195
    if (extraConfigBuilder && typeof extraConfigBuilder === "function") {
41✔
196
      const configBuilderData = extraConfigBuilder(table);
16✔
197
      if (configBuilderData) {
16✔
198
        // Convert configBuilderData to array if it's an object
199
        const configBuilders = Array.isArray(configBuilderData)
16✔
200
          ? configBuilderData
16!
201
          : Object.values(configBuilderData).map(
×
202
              (item) => (item as ConfigBuilderData).value ?? item,
×
203
            );
×
204

205
        // Process each builder
206
        configBuilders.forEach((builder) => {
16✔
207
          if (!builder?.constructor) return;
16!
208

209
          const builderName = builder.constructor.name.toLowerCase();
16✔
210

211
          // Map builder types to their corresponding arrays
212
          const builderMap = {
16✔
213
            indexbuilder: builders.indexes,
16✔
214
            checkbuilder: builders.checks,
16✔
215
            primarykeybuilder: builders.primaryKeys,
16✔
216
            uniqueconstraintbuilder: builders.uniqueConstraints,
16✔
217
          };
16✔
218

219
          // Add builder to appropriate array if it matches any type
220
          for (const [type, array] of Object.entries(builderMap)) {
16✔
221
            if (builderName.includes(type)) {
48✔
222
              array.push(builder);
16✔
223
              break;
16✔
224
            }
16✔
225
          }
48✔
226

227
          // Always add to extras array
228
          builders.extras.push(builder);
16✔
229
        });
16✔
230
      }
16✔
231
    }
16✔
232
  }
41✔
233

234
  return {
41✔
235
    tableName: nameSymbol ? (table as any)[nameSymbol] : "",
41!
236
    columns: columnsSymbol ? ((table as any)[columnsSymbol] as Record<string, AnyColumn>) : {},
41!
237
    ...builders,
41✔
238
  };
41✔
239
}
41✔
240

241
/**
242
 * Generates SQL statements for dropping tables and/or their sequences.
243
 *
244
 * @param tables - List of table names to generate DROP statements for.
245
 * @param options - Configuration object:
246
 *   - sequence: whether to drop associated sequences (default: true)
247
 *   - table: whether to drop tables themselves (default: true)
248
 * @returns Array of SQL statements for dropping the specified objects
249
 */
250
export function generateDropTableStatements(
1✔
251
  tables: string[],
4✔
252
  options?: { sequence: boolean; table: boolean },
4✔
253
): string[] {
4✔
254
  const dropStatements: string[] = [];
4✔
255
  const validOptions = options ?? { sequence: true, table: true };
4✔
256
  if (!validOptions.sequence && !validOptions.table) {
4!
NEW
257
    console.warn('No drop operations requested: both "table" and "sequence" options are false');
×
NEW
258
    return [];
×
UNCOV
259
  }
×
260
  tables.forEach((tableName) => {
4✔
261
    if (validOptions.table) {
6✔
262
      dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);
6✔
263
    }
6✔
264
    if (validOptions.sequence) {
6✔
265
      dropStatements.push(`DROP SEQUENCE IF EXISTS \`${tableName}\`;`);
6✔
266
    }
6✔
267
  });
4✔
268

269
  return dropStatements;
4✔
270
}
4✔
271

272
type AliasColumnMap = Record<string, AnyColumn>;
273

274
function mapSelectTableToAlias(
6✔
275
  table: MySqlTable,
6✔
276
  uniqPrefix: string,
6✔
277
  aliasMap: AliasColumnMap,
6✔
278
): any {
6✔
279
  const { columns, tableName } = getTableMetadata(table);
6✔
280
  const selectionsTableFields: Record<string, unknown> = {};
6✔
281
  Object.keys(columns).forEach((name) => {
6✔
282
    const column = columns[name] as AnyColumn;
23✔
283
    const uniqName = `a_${uniqPrefix}_${tableName}_${column.name}`.toLowerCase();
23✔
284
    const fieldAlias = sql.raw(uniqName);
23✔
285
    selectionsTableFields[name] = sql`${column} as \`${fieldAlias}\``;
23✔
286
    aliasMap[uniqName] = column;
23✔
287
  });
6✔
288
  return selectionsTableFields;
6✔
289
}
6✔
290

291
function isDrizzleColumn(column: any): boolean {
26✔
292
  return column && typeof column === "object" && "table" in column;
26✔
293
}
26✔
294

295
export function mapSelectAllFieldsToAlias(
1✔
296
  selections: any,
32✔
297
  name: string,
32✔
298
  uniqName: string,
32✔
299
  fields: any,
32✔
300
  aliasMap: AliasColumnMap,
32✔
301
): any {
32✔
302
  if (isTable(fields)) {
32✔
303
    selections[name] = mapSelectTableToAlias(fields as MySqlTable, uniqName, aliasMap);
6✔
304
  } else if (isDrizzleColumn(fields)) {
32✔
305
    const column = fields as Column;
14✔
306
    const uniqAliasName = `a_${uniqName}_${column.name}`.toLowerCase();
14✔
307
    let aliasName = sql.raw(uniqAliasName);
14✔
308
    selections[name] = sql`${column} as \`${aliasName}\``;
14✔
309
    aliasMap[uniqAliasName] = column;
14✔
310
  } else if (isSQLWrapper(fields)) {
26✔
311
    selections[name] = fields;
5✔
312
  } else {
12✔
313
    const innerSelections: any = {};
7✔
314
    Object.entries(fields).forEach(([iname, ifields]) => {
7✔
315
      mapSelectAllFieldsToAlias(innerSelections, iname, `${uniqName}_${iname}`, ifields, aliasMap);
14✔
316
    });
7✔
317
    selections[name] = innerSelections;
7✔
318
  }
7✔
319
  return selections;
32✔
320
}
32✔
321
export function mapSelectFieldsWithAlias<TSelection extends SelectedFields>(
1✔
322
  fields: TSelection,
6✔
323
): { selections: TSelection; aliasMap: AliasColumnMap } {
6✔
324
  if (!fields) {
6!
325
    throw new Error("fields is empty");
×
326
  }
×
327
  const aliasMap: AliasColumnMap = {};
6✔
328
  const selections: any = {};
6✔
329
  Object.entries(fields).forEach(([name, fields]) => {
6✔
330
    mapSelectAllFieldsToAlias(selections, name, name, fields, aliasMap);
18✔
331
  });
6✔
332
  return { selections, aliasMap };
6✔
333
}
6✔
334

335
function getAliasFromDrizzleAlias(value: unknown): string | undefined {
110✔
336
  const isSQL =
110✔
337
    value !== null && typeof value === "object" && isSQLWrapper(value) && "queryChunks" in value;
110✔
338
  if (isSQL) {
110✔
339
    const sql = value as SQL;
84✔
340
    const queryChunks = sql.queryChunks;
84✔
341
    if (queryChunks.length > 3) {
84✔
342
      const aliasNameChunk = queryChunks[queryChunks.length - 2];
74✔
343
      if (isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {
74✔
344
        const aliasNameChunkSql = aliasNameChunk as SQL;
74✔
345
        if (aliasNameChunkSql.queryChunks?.length === 1 && aliasNameChunkSql.queryChunks[0]) {
74✔
346
          const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];
74✔
347
          if ("value" in queryChunksStringChunc) {
74✔
348
            const values = (queryChunksStringChunc as StringChunk).value;
74✔
349
            if (values && values.length === 1) {
74✔
350
              return values[0];
74✔
351
            }
74✔
352
          }
74✔
353
        }
74✔
354
      }
74✔
355
    }
74✔
356
  }
84✔
357
  return undefined;
36✔
358
}
36✔
359

360
function transformValue(
74✔
361
  value: unknown,
74✔
362
  alias: string,
74✔
363
  aliasMap: Record<string, AnyColumn>,
74✔
364
): unknown {
74✔
365
  const column = aliasMap[alias];
74✔
366
  if (!column) return value;
74!
367

368
  let customColumn = column as MySqlCustomColumn<any>;
74✔
369
  // @ts-ignore
370
  const fromDriver = customColumn?.mapFrom;
74✔
371
  if (fromDriver && value !== null && value !== undefined) {
74✔
372
    return fromDriver(value);
14✔
373
  }
14✔
374
  return value;
60✔
375
}
60✔
376

377
function transformObject(
38✔
378
  obj: Record<string, unknown>,
38✔
379
  selections: Record<string, unknown>,
38✔
380
  aliasMap: Record<string, AnyColumn>,
38✔
381
): Record<string, unknown> {
38✔
382
  const result: Record<string, unknown> = {};
38✔
383

384
  for (const [key, value] of Object.entries(obj)) {
38✔
385
    const selection = selections[key];
110✔
386
    const alias = getAliasFromDrizzleAlias(selection);
110✔
387
    if (alias && aliasMap[alias]) {
110✔
388
      result[key] = transformValue(value, alias, aliasMap);
74✔
389
    } else if (selection && typeof selection === "object" && !isSQLWrapper(selection)) {
110✔
390
      result[key] = transformObject(
26✔
391
        value as Record<string, unknown>,
26✔
392
        selection as Record<string, unknown>,
26✔
393
        aliasMap,
26✔
394
      );
26✔
395
    } else {
36✔
396
      result[key] = value;
10✔
397
    }
10✔
398
  }
110✔
399

400
  return result;
38✔
401
}
38✔
402

403
export function applyFromDriverTransform<T, TSelection>(
1✔
404
  rows: T[],
6✔
405
  selections: TSelection,
6✔
406
  aliasMap: Record<string, AnyColumn>,
6✔
407
): T[] {
6✔
408
  return rows.map((row) => {
6✔
409
    const transformed = transformObject(
12✔
410
      row as Record<string, unknown>,
12✔
411
      selections as Record<string, unknown>,
12✔
412
      aliasMap,
12✔
413
    ) as Record<string, unknown>;
12✔
414

415
    return processNullBranches(transformed) as unknown as T;
12✔
416
  });
6✔
417
}
6✔
418

419
function processNullBranches(obj: Record<string, unknown>): Record<string, unknown> | null {
42✔
420
  if (obj === null || typeof obj !== "object") {
42!
421
    return obj;
×
422
  }
×
423

424
  // Skip built-in objects like Date, Array, etc.
425
  if (obj.constructor && obj.constructor.name !== "Object") {
42✔
426
    return obj;
4✔
427
  }
4✔
428

429
  const result: Record<string, unknown> = {};
38✔
430
  let allNull = true;
38✔
431

432
  for (const [key, value] of Object.entries(obj)) {
42✔
433
    if (value === null || value === undefined) {
110✔
434
      result[key] = null;
5✔
435
      continue;
5✔
436
    }
5✔
437

438
    if (typeof value === "object") {
110✔
439
      const processed = processNullBranches(value as Record<string, unknown>);
30✔
440
      result[key] = processed;
30✔
441
      if (processed !== null) {
30✔
442
        allNull = false;
29✔
443
      }
29✔
444
    } else {
110✔
445
      result[key] = value;
75✔
446
      allNull = false;
75✔
447
    }
75✔
448
  }
110✔
449

450
  return allNull ? null : result;
42✔
451
}
42✔
452

453
export function formatLimitOffset(limitOrOffset: number): number {
1✔
454
  if (typeof limitOrOffset !== "number" || isNaN(limitOrOffset)) {
5✔
455
    throw new Error("limitOrOffset must be a valid number");
2✔
456
  }
2✔
457
  return sql.raw(`${limitOrOffset}`) as unknown as number;
3✔
458
}
3✔
459

460
export function nextVal(sequenceName: string): number {
1✔
461
  return sql.raw(`NEXTVAL(${sequenceName})`) as unknown as number;
3✔
462
}
3✔
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc