18728243500

Committed 22 Oct 2025 07:58PM UTC coverage: 76.923% (-5.9%) from 82.832%

Build # 18728243500

Build Type

push

github

Committed by

vzakharchenko

Commit Message

fix tests

Run Details

452 of 676 branches covered (66.86%)

Branch coverage included in aggregate %.

948 of 1144 relevant lines covered (82.87%)

15.34 hits per line

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

79.78

/src/utils/sqlUtils.ts

import { AnyColumn, Column, isTable, SQL, sql, StringChunk } from "drizzle-orm";
import { AnyMySqlTable, MySqlCustomColumn } from "drizzle-orm/mysql-core/index";
import { DateTime } from "luxon";
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 or Date
 * @param format - The format to use for parsing
 * @returns Date object
 */

export const parseDateTime = (value: string | Date, format: string): Date => {
  let result: Date;
  if (value instanceof Date) {
    result = value;
  } else {
    // 1. Try to parse using the provided format (strict mode)
    const dt = DateTime.fromFormat(value, format);
    if (dt.isValid) {
      result = dt.toJSDate();
    } else {
      // 2. Try to parse as SQL string
      const sqlDt = DateTime.fromSQL(value);
      if (sqlDt.isValid) {
        result = sqlDt.toJSDate();
      } else {
        // 3. Try to parse as RFC2822 string
        const isoDt = DateTime.fromRFC2822(value);
        if (isoDt.isValid) {
          result = isoDt.toJSDate();
        } else {
          // 4. Fallback: use native Date constructor
          result = new Date(value);
        }
      }
    }
  }
  // 4. Ensure the result is a valid Date object
  if (isNaN(result.getTime())) {
    result = new Date(value);
  }
  return result;
};

/**
 * Helper function to validate and format a date-like value using Luxon DateTime.
 * @param value - Date object, ISO/RFC2822/SQL/HTTP string, or timestamp (number|string).
 * @param format - DateTime format string (Luxon format tokens).
 * @returns Formatted date string.
 * @throws Error if value cannot be parsed as a valid date.
 */
export function formatDateTime(
  value: Date | string | number,
  format: string,
  isTimeStamp: boolean,
): string {
  let dt: DateTime | null = null;

  if (value instanceof Date) {
    dt = DateTime.fromJSDate(value);
  } else if (typeof value === "string") {
    for (const parser of [
      DateTime.fromISO,
      DateTime.fromRFC2822,
      DateTime.fromSQL,
      DateTime.fromHTTP,
    ]) {
      dt = parser(value);
      if (dt.isValid) break;
    }
    if (!dt?.isValid) {
      const parsed = Number(value);
      if (!isNaN(parsed)) {
        dt = DateTime.fromMillis(parsed);
      }
    }
  } else if (typeof value === "number") {
    dt = DateTime.fromMillis(value);
  } else {
    throw new Error("Unsupported type");
  }

  if (!dt?.isValid) {
    throw new Error("Invalid Date");
  }
  const minDate = DateTime.fromSeconds(1);
  const maxDate = DateTime.fromMillis(2147483647 * 1000); // 2038-01-19 03:14:07.999 UTC

  if (isTimeStamp) {
    if (dt < minDate) {
      throw new Error(
        "Atlassian Forge does not support zero or negative timestamps. Allowed range: from '1970-01-01 00:00:01.000000' to '2038-01-19 03:14:07.999999'.",
      );
    }
    if (dt > maxDate) {
      throw new Error(
        "Atlassian Forge does not support timestamps beyond 2038-01-19 03:14:07.999999. Please use a smaller date within the supported range.",
      );
    }
  }

  return dt.toFormat(format);
}

/**
 * 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 for dropping tables and/or their sequences.
 *
 * @param tables - List of table names to generate DROP statements for.
 * @param options - Configuration object:
 *   - sequence: whether to drop associated sequences (default: true)
 *   - table: whether to drop tables themselves (default: true)
 * @returns Array of SQL statements for dropping the specified objects
 */
export function generateDropTableStatements(
  tables: string[],
  options?: { sequence: boolean; table: boolean },
): string[] {
  const dropStatements: string[] = [];
  const validOptions = options ?? { sequence: true, table: true };
  if (!validOptions.sequence && !validOptions.table) {
    // eslint-disable-next-line no-console
    console.warn('No drop operations requested: both "table" and "sequence" options are false');
    return [];
  }
  tables.forEach((tableName) => {
    if (validOptions.table) {
      dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);
    }
    if (validOptions.sequence) {
      dropStatements.push(`DROP SEQUENCE 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;
}

export function formatLimitOffset(limitOrOffset: number): number {
  if (typeof limitOrOffset !== "number" || isNaN(limitOrOffset)) {
    throw new Error("limitOrOffset must be a valid number");
  }
  return sql.raw(`${limitOrOffset}`) as unknown as number;
}

export function nextVal(sequenceName: string): number {
  return sql.raw(`NEXTVAL(${sequenceName})`) as unknown as number;
}

1	import { AnyColumn, Column, isTable, SQL, sql, StringChunk } from "drizzle-orm";
2	import { AnyMySqlTable, MySqlCustomColumn } from "drizzle-orm/mysql-core/index";
3	import { DateTime } from "luxon";
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";
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 or Date
46	* @param format - The format to use for parsing
47	* @returns Date object
48	*/
49
50	export const parseDateTime = (value: string \| Date, format: string): Date => {	4✔
51	let result: Date;
52	if (value instanceof Date) {	13✔
53	result = value;	1✔
54	} else {
55	// 1. Try to parse using the provided format (strict mode)
56	const dt = DateTime.fromFormat(value, format);	12✔
57	if (dt.isValid) {	12✔
58	result = dt.toJSDate();	2✔
59	} else {
60	// 2. Try to parse as SQL string
61	const sqlDt = DateTime.fromSQL(value);	10✔
62	if (sqlDt.isValid) {	10✔
63	result = sqlDt.toJSDate();	4✔
64	} else {
65	// 3. Try to parse as RFC2822 string
66	const isoDt = DateTime.fromRFC2822(value);	6✔
67	if (isoDt.isValid) {	6!
68	result = isoDt.toJSDate();	×
69	} else {
70	// 4. Fallback: use native Date constructor
71	result = new Date(value);	6✔
72	}
73	}
74	}
75	}
76	// 4. Ensure the result is a valid Date object
77	if (isNaN(result.getTime())) {	13✔
78	result = new Date(value);	4✔
79	}
80	return result;	13✔
81	};
82
83	/**
84	* Helper function to validate and format a date-like value using Luxon DateTime.
85	* @param value - Date object, ISO/RFC2822/SQL/HTTP string, or timestamp (number\|string).
86	* @param format - DateTime format string (Luxon format tokens).
87	* @returns Formatted date string.
88	* @throws Error if value cannot be parsed as a valid date.
89	*/
90	export function formatDateTime(
91	value: Date \| string \| number,
92	format: string,
93	isTimeStamp: boolean,
94	): string {
95	let dt: DateTime \| null = null;	13✔
96
97	if (value instanceof Date) {	13!
98	dt = DateTime.fromJSDate(value);	13✔
99	} else if (typeof value === "string") {	×
100	for (const parser of [	×
101	DateTime.fromISO,
102	DateTime.fromRFC2822,
103	DateTime.fromSQL,
104	DateTime.fromHTTP,
105	]) {
106	dt = parser(value);	×
107	if (dt.isValid) break;	×
108	}
109	if (!dt?.isValid) {	×
110	const parsed = Number(value);	×
111	if (!isNaN(parsed)) {	×
112	dt = DateTime.fromMillis(parsed);	×
113	}
114	}
115	} else if (typeof value === "number") {	×
116	dt = DateTime.fromMillis(value);	×
117	} else {
118	throw new Error("Unsupported type");	×
119	}
120
121	if (!dt?.isValid) {	13!
122	throw new Error("Invalid Date");	×
123	}
124	const minDate = DateTime.fromSeconds(1);	13✔
125	const maxDate = DateTime.fromMillis(2147483647 * 1000); // 2038-01-19 03:14:07.999 UTC	13✔
126
127	if (isTimeStamp) {	13✔
128	if (dt < minDate) {	2!
129	throw new Error(	×
130	"Atlassian Forge does not support zero or negative timestamps. Allowed range: from '1970-01-01 00:00:01.000000' to '2038-01-19 03:14:07.999999'.",
131	);
132	}
133	if (dt > maxDate) {	2!
134	throw new Error(	×
135	"Atlassian Forge does not support timestamps beyond 2038-01-19 03:14:07.999999. Please use a smaller date within the supported range.",
136	);
137	}
138	}
139
140	return dt.toFormat(format);	13✔
141	}
142
143	/**
144	* Gets primary keys from the schema.
145	* @template T - The type of the table schema
146	* @param {T} table - The table schema
147	* @returns {[string, AnyColumn][]} Array of primary key name and column pairs
148	*/
149	export function getPrimaryKeys<T extends AnyMySqlTable>(table: T): [string, AnyColumn][] {
150	const { columns, primaryKeys } = getTableMetadata(table);	14✔
151
152	// First try to find primary keys in columns
153	const columnPrimaryKeys = Object.entries(columns).filter(([, column]) => column.primary) as [	38✔
154	string,
155	AnyColumn,
156	][];
157
158	if (columnPrimaryKeys.length > 0) {	14✔
159	return columnPrimaryKeys;	10✔
160	}
161
162	// If no primary keys found in columns, check primary key builders
163	if (Array.isArray(primaryKeys) && primaryKeys.length > 0) {	4!
164	// Collect all primary key columns from all primary key builders
165	const primaryKeyColumns = new Set<[string, AnyColumn]>();	4✔
166
167	primaryKeys.forEach((primaryKeyBuilder) => {	4✔
168	// Get primary key columns from each builder
169	Object.entries(columns)	4✔
170	.filter(([, column]) => {
171	// @ts-ignore - PrimaryKeyBuilder has internal columns property
172	return primaryKeyBuilder.columns.includes(column);	8✔
173	})
174	.forEach(([name, column]) => {
175	primaryKeyColumns.add([name, column]);	4✔
176	});
177	});
178
179	return Array.from(primaryKeyColumns);	4✔
180	}
181
182	return [];	×
183	}
184
185	/**
186	* Processes foreign keys from both foreignKeysSymbol and extraSymbol
187	* @param table - The table schema
188	* @param foreignKeysSymbol - Symbol for foreign keys
189	* @param extraSymbol - Symbol for extra configuration
190	* @returns Array of foreign key builders
191	*/
192	function processForeignKeys(
193	table: AnyMySqlTable,
194	foreignKeysSymbol: symbol \| undefined,
195	extraSymbol: symbol \| undefined,
196	): ForeignKeyBuilder[] {
197	const foreignKeys: ForeignKeyBuilder[] = [];	46✔
198
199	// Process foreign keys from foreignKeysSymbol
200	if (foreignKeysSymbol) {	46!
201	// @ts-ignore
202	const fkArray: any[] = table[foreignKeysSymbol];	46✔
203	if (fkArray) {	46!
204	fkArray.forEach((fk) => {	46✔
205	if (fk.reference) {	×
206	const item = fk.reference(fk);	×
207	foreignKeys.push(item);	×
208	}
209	});
210	}
211	}
212
213	// Process foreign keys from extraSymbol
214	if (extraSymbol) {	46!
215	// @ts-ignore
216	const extraConfigBuilder = table[extraSymbol];	46✔
217	if (extraConfigBuilder && typeof extraConfigBuilder === "function") {	46✔
218	const configBuilderData = extraConfigBuilder(table);	21✔
219	if (configBuilderData) {	21!
220	const configBuilders = Array.isArray(configBuilderData)	21!
221	? configBuilderData
222	: Object.values(configBuilderData).map(
223	(item) => (item as ConfigBuilderData).value ?? item,	×
224	);
225
226	configBuilders.forEach((builder) => {	21✔
227	if (!builder?.constructor) return;	21!
228
229	const builderName = builder.constructor.name.toLowerCase();	21✔
230	if (builderName.includes("foreignkeybuilder")) {	21!
231	foreignKeys.push(builder);	×
232	}
233	});
234	}
235	}
236	}
237
238	return foreignKeys;	46✔
239	}
240
241	/**
242	* Extracts table metadata from the schema.
243	* @param {AnyMySqlTable} table - The table schema
244	* @returns {MetadataInfo} Object containing table metadata
245	*/
246	export function getTableMetadata(table: AnyMySqlTable): MetadataInfo {
247	const symbols = Object.getOwnPropertySymbols(table);	46✔
248	const nameSymbol = symbols.find((s) => s.toString().includes("Name"));	46✔
249	const columnsSymbol = symbols.find((s) => s.toString().includes("Columns"));	184✔
250	const foreignKeysSymbol = symbols.find((s) => s.toString().includes("ForeignKeys)"));	460✔
251	const extraSymbol = symbols.find((s) => s.toString().includes("ExtraConfigBuilder"));	414✔
252
253	// Initialize builders arrays
254	const builders = {	46✔
255	indexes: [] as AnyIndexBuilder[],
256	checks: [] as CheckBuilder[],
257	foreignKeys: [] as ForeignKeyBuilder[],
258	primaryKeys: [] as PrimaryKeyBuilder[],
259	uniqueConstraints: [] as UniqueConstraintBuilder[],
260	extras: [] as any[],
261	};
262
263	// Process foreign keys
264	builders.foreignKeys = processForeignKeys(table, foreignKeysSymbol, extraSymbol);	46✔
265
266	// Process extra configuration if available
267	if (extraSymbol) {	46!
268	// @ts-ignore
269	const extraConfigBuilder = table[extraSymbol];	46✔
270	if (extraConfigBuilder && typeof extraConfigBuilder === "function") {	46✔
271	const configBuilderData = extraConfigBuilder(table);	21✔
272	if (configBuilderData) {	21!
273	// Convert configBuilderData to array if it's an object
274	const configBuilders = Array.isArray(configBuilderData)	21!
275	? configBuilderData
276	: Object.values(configBuilderData).map(
277	(item) => (item as ConfigBuilderData).value ?? item,	×
278	);
279
280	// Process each builder
281	configBuilders.forEach((builder) => {	21✔
282	if (!builder?.constructor) return;	21!
283
284	const builderName = builder.constructor.name.toLowerCase();	21✔
285
286	// Map builder types to their corresponding arrays
287	const builderMap = {	21✔
288	indexbuilder: builders.indexes,
289	checkbuilder: builders.checks,
290	primarykeybuilder: builders.primaryKeys,
291	uniqueconstraintbuilder: builders.uniqueConstraints,
292	};
293
294	// Add builder to appropriate array if it matches any type
295	for (const [type, array] of Object.entries(builderMap)) {	21✔
296	if (builderName.includes(type)) {	63✔
297	array.push(builder);	21✔
298	break;	21✔
299	}
300	}
301
302	// Always add to extras array
303	builders.extras.push(builder);	21✔
304	});
305	}
306	}
307	}
308
309	return {	46✔
310	tableName: nameSymbol ? (table as any)[nameSymbol] : "",	46!
311	columns: columnsSymbol ? ((table as any)[columnsSymbol] as Record<string, AnyColumn>) : {},	46!
312	...builders,
313	};
314	}
315
316	/**
317	* Generates SQL statements for dropping tables and/or their sequences.
318	*
319	* @param tables - List of table names to generate DROP statements for.
320	* @param options - Configuration object:
321	* - sequence: whether to drop associated sequences (default: true)
322	* - table: whether to drop tables themselves (default: true)
323	* @returns Array of SQL statements for dropping the specified objects
324	*/
325	export function generateDropTableStatements(
326	tables: string[],
327	options?: { sequence: boolean; table: boolean },
328	): string[] {
329	const dropStatements: string[] = [];	4✔
330	const validOptions = options ?? { sequence: true, table: true };	4✔
331	if (!validOptions.sequence && !validOptions.table) {	4!
332	// eslint-disable-next-line no-console
333	console.warn('No drop operations requested: both "table" and "sequence" options are false');	×
334	return [];	×
335	}
336	tables.forEach((tableName) => {	4✔
337	if (validOptions.table) {	6!
338	dropStatements.push(`DROP TABLE IF EXISTS \`${tableName}\`;`);	6✔
339	}
340	if (validOptions.sequence) {	6!
341	dropStatements.push(`DROP SEQUENCE IF EXISTS \`${tableName}\`;`);	6✔
342	}
343	});
344
345	return dropStatements;	4✔
346	}
347
348	type AliasColumnMap = Record<string, AnyColumn>;
349
350	function mapSelectTableToAlias(
351	table: MySqlTable,
352	uniqPrefix: string,
353	aliasMap: AliasColumnMap,
354	): any {
355	const { columns, tableName } = getTableMetadata(table);	10✔
356	const selectionsTableFields: Record<string, unknown> = {};	10✔
357	Object.keys(columns).forEach((name) => {	10✔
358	const column = columns[name] as AnyColumn;	39✔
359	const uniqName = `a_${uniqPrefix}_${tableName}_${column.name}`.toLowerCase();	39✔
360	const fieldAlias = sql.raw(uniqName);	39✔
361	selectionsTableFields[name] = sql`${column} as \`${fieldAlias}\``;	39✔
362	aliasMap[uniqName] = column;	39✔
363	});
364	return selectionsTableFields;	10✔
365	}
366
367	function isDrizzleColumn(column: any): boolean {
368	return column && typeof column === "object" && "table" in column;	80✔
369	}
370
371	export function mapSelectAllFieldsToAlias(
372	selections: any,
373	name: string,
374	uniqName: string,
375	fields: any,
376	aliasMap: AliasColumnMap,
377	): any {
378	if (isTable(fields)) {	90✔
379	selections[name] = mapSelectTableToAlias(fields as MySqlTable, uniqName, aliasMap);	10✔
380	} else if (isDrizzleColumn(fields)) {	80✔
381	const column = fields as Column;	59✔
382	const uniqAliasName = `a_${uniqName}_${column.name}`.toLowerCase();	59✔
383	let aliasName = sql.raw(uniqAliasName);	59✔
384	selections[name] = sql`${column} as \`${aliasName}\``;	59✔
385	aliasMap[uniqAliasName] = column;	59✔
386	} else if (isSQLWrapper(fields)) {	21✔
387	selections[name] = fields;	10✔
388	} else {
389	const innerSelections: any = {};	11✔
390	Object.entries(fields).forEach(([iname, ifields]) => {	11✔
391	mapSelectAllFieldsToAlias(innerSelections, iname, `${uniqName}_${iname}`, ifields, aliasMap);	22✔
392	});
393	selections[name] = innerSelections;	11✔
394	}
395	return selections;	90✔
396	}
397	export function mapSelectFieldsWithAlias<TSelection extends SelectedFields>(
398	fields: TSelection,
399	): { selections: TSelection; aliasMap: AliasColumnMap } {
400	if (!fields) {	30!
401	throw new Error("fields is empty");	×
402	}
403	const aliasMap: AliasColumnMap = {};	30✔
404	const selections: any = {};	30✔
405	Object.entries(fields).forEach(([name, fields]) => {	30✔
406	mapSelectAllFieldsToAlias(selections, name, name, fields, aliasMap);	68✔
407	});
408	return { selections, aliasMap };	30✔
409	}
410
411	function getAliasFromDrizzleAlias(value: unknown): string \| undefined {
412	const isSQL =
413	value !== null && typeof value === "object" && isSQLWrapper(value) && "queryChunks" in value;	201✔
414	if (isSQL) {	201✔
415	const sql = value as SQL;	159✔
416	const queryChunks = sql.queryChunks;	159✔
417	if (queryChunks.length > 3) {	159✔
418	const aliasNameChunk = queryChunks[queryChunks.length - 2];	141✔
419	if (isSQLWrapper(aliasNameChunk) && "queryChunks" in aliasNameChunk) {	141!
420	const aliasNameChunkSql = aliasNameChunk as SQL;	141✔
421	if (aliasNameChunkSql.queryChunks?.length === 1 && aliasNameChunkSql.queryChunks[0]) {	141!
422	const queryChunksStringChunc = aliasNameChunkSql.queryChunks[0];	141✔
423	if ("value" in queryChunksStringChunc) {	141!
424	const values = (queryChunksStringChunc as StringChunk).value;	141✔
425	if (values && values.length === 1) {	141!
426	return values[0];	141✔
427	}
428	}
429	}
430	}
431	}
432	}
433	return undefined;	60✔
434	}
435
436	function transformValue(
437	value: unknown,
438	alias: string,
439	aliasMap: Record<string, AnyColumn>,
440	): unknown {
441	const column = aliasMap[alias];	141✔
442	if (!column) return value;	141!
443
444	let customColumn = column as MySqlCustomColumn<any>;	141✔
445	// @ts-ignore
446	const fromDriver = customColumn?.mapFrom;	141✔
447	if (fromDriver && value !== null && value !== undefined) {	141✔
448	return fromDriver(value);	26✔
449	}
450	return value;	115✔
451	}
452
453	function transformObject(
454	obj: Record<string, unknown>,
455	selections: Record<string, unknown>,
456	aliasMap: Record<string, AnyColumn>,
457	): Record<string, unknown> {
458	const result: Record<string, unknown> = {};	72✔
459
460	for (const [key, value] of Object.entries(obj)) {	72✔
461	const selection = selections[key];	201✔
462	const alias = getAliasFromDrizzleAlias(selection);	201✔
463	if (alias && aliasMap[alias]) {	201✔
464	result[key] = transformValue(value, alias, aliasMap);	141✔
465	} else if (selection && typeof selection === "object" && !isSQLWrapper(selection)) {	60✔
466	result[key] = transformObject(	42✔
467	value as Record<string, unknown>,
468	selection as Record<string, unknown>,
469	aliasMap,
470	);
471	} else {
472	result[key] = value;	18✔
473	}
474	}
475
476	return result;	72✔
477	}
478
479	export function applyFromDriverTransform<T, TSelection>(
480	rows: T[],
481	selections: TSelection,
482	aliasMap: Record<string, AnyColumn>,
483	): T[] {
484	return rows.map((row) => {	22✔
485	const transformed = transformObject(	30✔
486	row as Record<string, unknown>,
487	selections as Record<string, unknown>,
488	aliasMap,
489	) as Record<string, unknown>;
490
491	return processNullBranches(transformed) as unknown as T;	30✔
492	});
493	}
494
495	function processNullBranches(obj: Record<string, unknown>): Record<string, unknown> \| null {
496	if (obj === null \|\| typeof obj !== "object") {	80!
497	return obj;	×
498	}
499
500	// Skip built-in objects like Date, Array, etc.
501	if (obj.constructor && obj.constructor.name !== "Object") {	80✔
502	return obj;	8✔
503	}
504
505	const result: Record<string, unknown> = {};	72✔
506	let allNull = true;	72✔
507
508	for (const [key, value] of Object.entries(obj)) {	72✔
509	if (value === null \|\| value === undefined) {	201✔
510	result[key] = null;	5✔
511	continue;	5✔
512	}
513
514	if (typeof value === "object") {	196✔
515	const processed = processNullBranches(value as Record<string, unknown>);	50✔
516	result[key] = processed;	50✔
517	if (processed !== null) {	50✔
518	allNull = false;	49✔
519	}
520	} else {
521	result[key] = value;	146✔
522	allNull = false;	146✔
523	}
524	}
525
526	return allNull ? null : result;	72✔
527	}
528
529	export function formatLimitOffset(limitOrOffset: number): number {
530	if (typeof limitOrOffset !== "number" \|\| isNaN(limitOrOffset)) {	5✔
531	throw new Error("limitOrOffset must be a valid number");	2✔
532	}
533	return sql.raw(`${limitOrOffset}`) as unknown as number;	3✔
534	}
535
536	export function nextVal(sequenceName: string): number {
537	return sql.raw(`NEXTVAL(${sequenceName})`) as unknown as number;	3✔
538	}

vzakharchenko / forge-sql-orm / 18728243500

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