joist-migration-utils 2.3.0-next.7 → 2.3.0-next.71

package/build/utils.d.cts

@@ -0,0 +1,97 @@
+import { ColumnDefinition, ColumnDefinitions, DropOptions, MigrationBuilder, TableOptions } from "node-pg-migrate";
+//#region src/utils.d.ts
+/**
+ * Creates an entity table with our conventions.
+ *
+ * Specifically an `id` auto-increment column (via a sequence) and `created_at` and `updated_at`
+ * columns.
+ */
+declare function createEntityTable(b: MigrationBuilder, tableName: string, columns: ColumnDefinitions): void;
+/**
+ * Creates a subtype table using class-per-table inheritance.
+ *
+ * The subtable will use the base table's id as its identity, and when loading rows of the base
+ * type, Joist will automatically stitch together rows across each table into a single instance.
+ */
+declare function createSubTable(b: MigrationBuilder, baseTableName: string, subTableName: string, columns: ColumnDefinitions): void;
+declare function createEnumTable(b: MigrationBuilder, tableName: string, values: Array<[string, string]>): void;
+declare function addEnumValue(b: MigrationBuilder, tableName: string, value: [string, string]): void;
+declare function updateEnumValue(b: MigrationBuilder, tableName: string, previousCode: string, value: [string, string]): void;
+/** Makes a trigger to update the `updated_at` column. */
+declare function createTriggers(b: MigrationBuilder, tableName: string): void;
+declare function createUpdatedAtFunction(b: MigrationBuilder): void;
+/**
+ * Unnests a 2d array like `[[a, b], [c, d]]` into two rows of `[a, b]` and `[c, d]`.
+ *
+ * This custom function is a key part of Joist's bulk INSERT/UPDATE that sends "all firstNames as
+ * a single param", because it lets us support array columns as a single parameter (i.e. an array
+ * of arrays).
+ *
+ * Postgres's built-in `unnest` is too aggressive when flattening, and will unnest the 2d array
+ * of `[[a, b], [c, d]]` into four rows of `a`, `b`, `c`, and `d`, which is not what we want.
+ *
+ * Additionally, Postgres does not support "jagged arrays", i.e. 2D arrays where some
+ * sub-arrays are longer than others, e.g. `[[a, b], [c, d, e]]`. Instead, it treats arrays
+ * more as the mathematical concept of a matrix, than "a list of lists".
+ *
+ * To work around this, our PostgresDriver auto-pads all 2D arrays to the same length, by
+ * appending `NULL`, and then `unnest_arrays` prunes all `NULL`s from the resulting 1D arrays.
+ * See `fillArrayWithNulls`.
+ *
+ *
+ * This means we purposefully do not/cannot support `NULL` values _within_ array columns,
+ * i.e. `nick_names=[a, NULL, b]` (without some additional heuristics).
+ *
+ * That said, we do need to support nullable array columns, i.e. `nick_names=NULL`, which we
+ * detect by prefixing an additional marker element to each sub-array that indicates whether the
+ * array column is null or not, and then conditionally enabling this with the `nullable=true`
+ * param to `unnest_arrays`.
+ */
+declare const unnest_arrays = "\nCREATE OR REPLACE FUNCTION unnest_arrays(arr ANYARRAY, nullable BOOLEAN = false, OUT a ANYARRAY)\n  RETURNS SETOF ANYARRAY\n  LANGUAGE plpgsql IMMUTABLE STRICT AS\n$func$\nBEGIN\n  FOREACH a SLICE 1 IN ARRAY arr LOOP\n    IF nullable THEN\n      IF a[1] IS NULL THEN a := NULL;\n      ELSE a := a[2:array_length(a, 1)];\n      END IF;\n    END IF;\n    a := array_remove(a, NULL);\n    RETURN NEXT;\n  END LOOP;\nEND\n$func$;\n";
+declare function createUnnestArraysFunction(b: MigrationBuilder): void;
+declare function createCreatedAtFunction(b: MigrationBuilder): void;
+type FieldNameOverrides = {
+  fieldName?: string;
+  otherFieldName?: string;
+};
+type ForeignKeyOpts = Partial<ColumnDefinition> & Required<Pick<ColumnDefinition, "notNull">> & FieldNameOverrides;
+declare function foreignKey(otherTable: string, opts: ForeignKeyOpts): ColumnDefinition;
+type RenameRelationOpts = FieldNameOverrides & Pick<ColumnDefinition, "comment">;
+declare function renameRelation(b: MigrationBuilder, tableName: string, columnName: string, opts: RenameRelationOpts): void;
+declare function commentData(data: any, comment?: string | null): string;
+declare function enumArrayColumn(enumTable: string, opts?: Pick<ColumnDefinition, "notNull">): ColumnDefinition;
+type ManyToManyColumn = {
+  /** The target table for this m2m table, i.e. for a `books_to_tags`, this might be `books`. */
+  table: string;
+  /** The column name within the m2m table, i.e. for a `books_to_tags`, this might be `book_id`. */
+  column?: string;
+  /**
+   * The name of the collection that *points to* these rows, i.e. for `books_to_tags` and the `book_id`
+   * column, `collectionName=taggedBooks` b/c `t1.taggedBooks` does a `SELECT book_id WHERE tag_id=t:1`.
+   *
+   * For self-referential m2m tables, i.e. `author_to_mentors`, these names can be confusing, i.e.:
+   *
+   * ```
+   * createManyToManyTable(
+   *   b,
+   *   "author_to_mentors",
+   *   // column=mentor_id, collectionName=mentors ==> `a.mentors` does `select mentor_id WHERE mentee_id=a:1`
+   *   { table: "authors", column: "mentor_id", collectionName: "mentors" },
+   *   // column=mentee_id, collectionName=mentees ==> `a.mentees` does `select mentee_id WHERE mentor_id=a:1`
+   *   { table: "authors", column: "mentee_id", collectionName: "mentees" },
+   * );
+   * ````
+   */
+  collectionName?: string;
+};
+/** Creates a many-to-many table between `table1` and `table2` with our conventions. */
+declare function createManyToManyTable(b: MigrationBuilder, tableName: string, table1: string, table2: string, options?: TableOptions & DropOptions): void;
+declare function createManyToManyTable(b: MigrationBuilder, tableName: string, column1: ManyToManyColumn, column2: ManyToManyColumn, options?: TableOptions & DropOptions): void;
+declare function createManyToManyTable(b: MigrationBuilder, tableName: string, table1: string, column2: ManyToManyColumn, options?: TableOptions & DropOptions): void;
+declare function createManyToManyTable(b: MigrationBuilder, tableName: string, column1: ManyToManyColumn, table2: string, options?: TableOptions & DropOptions): void;
+/** Adds columns + auto-indexes any foreign keys. */
+declare function addColumns(b: MigrationBuilder, tableName: string, columns: ColumnDefinitions): void;
+declare function fail(message?: string): never;
+//#endregion
+export { FieldNameOverrides, RenameRelationOpts, addColumns, addEnumValue, commentData, createCreatedAtFunction, createEntityTable, createEnumTable, createManyToManyTable, createSubTable, createTriggers, createUnnestArraysFunction, createUpdatedAtFunction, enumArrayColumn, fail, foreignKey, renameRelation, unnest_arrays, updateEnumValue };
+//# sourceMappingURL=utils.d.cts.map

package/build/utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":[],"sources":["../src/utils.ts"],"mappings":";;;;;;;;iBAkBgB,kBAAkB,GAAG,kBAAkB,mBAAmB,SAAS;;;;;;;iBAyBnE,eACd,GAAG,kBACH,uBACA,sBACA,SAAS;iBAsBK,gBAAgB,GAAG,kBAAkB,mBAAmB,QAAQ;iBAShE,aAAa,GAAG,kBAAkB,mBAAmB;iBAMrD,gBACd,GAAG,kBACH,mBACA,sBACA;;iBAcc,eAAe,GAAG,kBAAkB;iBAepC,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoC9B;iBAmBG,2BAA2B,GAAG;iBAI9B,wBAAwB,GAAG;KAS/B;EACV;EACA;;KAEG,iBAAiB,QAAQ,oBAAoB,SAAS,KAAK,gCAAgC;iBAChF,WAAW,oBAAoB,MAAM,iBAAiB;KAU1D,qBAAqB,qBAAqB,KAAK;iBAC3C,eAAe,GAAG,kBAAkB,mBAAmB,oBAAoB,MAAM;iBAIjF,YAAY,WAAW;iBAkBvB,gBAAgB,mBAAmB,OAAO,KAAK,+BAA+B;KAazF;;EAEH;;EAEA;;;;;;;;;;;;;;;;;;EAkBA;;;iBAac,sBACd,GAAG,kBACH,mBACA,gBACA,gBACA,UAAU,eAAe;iBAEX,sBACd,GAAG,kBACH,mBACA,SAAS,kBACT,SAAS,kBACT,UAAU,eAAe;iBAEX,sBACd,GAAG,kBACH,mBACA,gBACA,SAAS,kBACT,UAAU,eAAe;iBAEX,sBACd,GAAG,kBACH,mBACA,SAAS,kBACT,gBACA,UAAU,eAAe;;iBA0BX,WAAW,GAAG,kBAAkB,mBAAmB,SAAS;iBAS5D,KAAK"}

package/build/utils.d.mts

@@ -0,0 +1,97 @@
+import { ColumnDefinition, ColumnDefinitions, DropOptions, MigrationBuilder, TableOptions } from "node-pg-migrate";
+//#region src/utils.d.ts
+/**
+ * Creates an entity table with our conventions.
+ *
+ * Specifically an `id` auto-increment column (via a sequence) and `created_at` and `updated_at`
+ * columns.
+ */
+declare function createEntityTable(b: MigrationBuilder, tableName: string, columns: ColumnDefinitions): void;
+/**
+ * Creates a subtype table using class-per-table inheritance.
+ *
+ * The subtable will use the base table's id as its identity, and when loading rows of the base
+ * type, Joist will automatically stitch together rows across each table into a single instance.
+ */
+declare function createSubTable(b: MigrationBuilder, baseTableName: string, subTableName: string, columns: ColumnDefinitions): void;
+declare function createEnumTable(b: MigrationBuilder, tableName: string, values: Array<[string, string]>): void;
+declare function addEnumValue(b: MigrationBuilder, tableName: string, value: [string, string]): void;
+declare function updateEnumValue(b: MigrationBuilder, tableName: string, previousCode: string, value: [string, string]): void;
+/** Makes a trigger to update the `updated_at` column. */
+declare function createTriggers(b: MigrationBuilder, tableName: string): void;
+declare function createUpdatedAtFunction(b: MigrationBuilder): void;
+/**
+ * Unnests a 2d array like `[[a, b], [c, d]]` into two rows of `[a, b]` and `[c, d]`.
+ *
+ * This custom function is a key part of Joist's bulk INSERT/UPDATE that sends "all firstNames as
+ * a single param", because it lets us support array columns as a single parameter (i.e. an array
+ * of arrays).
+ *
+ * Postgres's built-in `unnest` is too aggressive when flattening, and will unnest the 2d array
+ * of `[[a, b], [c, d]]` into four rows of `a`, `b`, `c`, and `d`, which is not what we want.
+ *
+ * Additionally, Postgres does not support "jagged arrays", i.e. 2D arrays where some
+ * sub-arrays are longer than others, e.g. `[[a, b], [c, d, e]]`. Instead, it treats arrays
+ * more as the mathematical concept of a matrix, than "a list of lists".
+ *
+ * To work around this, our PostgresDriver auto-pads all 2D arrays to the same length, by
+ * appending `NULL`, and then `unnest_arrays` prunes all `NULL`s from the resulting 1D arrays.
+ * See `fillArrayWithNulls`.
+ *
+ *
+ * This means we purposefully do not/cannot support `NULL` values _within_ array columns,
+ * i.e. `nick_names=[a, NULL, b]` (without some additional heuristics).
+ *
+ * That said, we do need to support nullable array columns, i.e. `nick_names=NULL`, which we
+ * detect by prefixing an additional marker element to each sub-array that indicates whether the
+ * array column is null or not, and then conditionally enabling this with the `nullable=true`
+ * param to `unnest_arrays`.
+ */
+declare const unnest_arrays = "\nCREATE OR REPLACE FUNCTION unnest_arrays(arr ANYARRAY, nullable BOOLEAN = false, OUT a ANYARRAY)\n  RETURNS SETOF ANYARRAY\n  LANGUAGE plpgsql IMMUTABLE STRICT AS\n$func$\nBEGIN\n  FOREACH a SLICE 1 IN ARRAY arr LOOP\n    IF nullable THEN\n      IF a[1] IS NULL THEN a := NULL;\n      ELSE a := a[2:array_length(a, 1)];\n      END IF;\n    END IF;\n    a := array_remove(a, NULL);\n    RETURN NEXT;\n  END LOOP;\nEND\n$func$;\n";
+declare function createUnnestArraysFunction(b: MigrationBuilder): void;
+declare function createCreatedAtFunction(b: MigrationBuilder): void;
+type FieldNameOverrides = {
+  fieldName?: string;
+  otherFieldName?: string;
+};
+type ForeignKeyOpts = Partial<ColumnDefinition> & Required<Pick<ColumnDefinition, "notNull">> & FieldNameOverrides;
+declare function foreignKey(otherTable: string, opts: ForeignKeyOpts): ColumnDefinition;
+type RenameRelationOpts = FieldNameOverrides & Pick<ColumnDefinition, "comment">;
+declare function renameRelation(b: MigrationBuilder, tableName: string, columnName: string, opts: RenameRelationOpts): void;
+declare function commentData(data: any, comment?: string | null): string;
+declare function enumArrayColumn(enumTable: string, opts?: Pick<ColumnDefinition, "notNull">): ColumnDefinition;
+type ManyToManyColumn = {
+  /** The target table for this m2m table, i.e. for a `books_to_tags`, this might be `books`. */
+  table: string;
+  /** The column name within the m2m table, i.e. for a `books_to_tags`, this might be `book_id`. */
+  column?: string;
+  /**
+   * The name of the collection that *points to* these rows, i.e. for `books_to_tags` and the `book_id`
+   * column, `collectionName=taggedBooks` b/c `t1.taggedBooks` does a `SELECT book_id WHERE tag_id=t:1`.
+   *
+   * For self-referential m2m tables, i.e. `author_to_mentors`, these names can be confusing, i.e.:
+   *
+   * ```
+   * createManyToManyTable(
+   *   b,
+   *   "author_to_mentors",
+   *   // column=mentor_id, collectionName=mentors ==> `a.mentors` does `select mentor_id WHERE mentee_id=a:1`
+   *   { table: "authors", column: "mentor_id", collectionName: "mentors" },
+   *   // column=mentee_id, collectionName=mentees ==> `a.mentees` does `select mentee_id WHERE mentor_id=a:1`
+   *   { table: "authors", column: "mentee_id", collectionName: "mentees" },
+   * );
+   * ````
+   */
+  collectionName?: string;
+};
+/** Creates a many-to-many table between `table1` and `table2` with our conventions. */
+declare function createManyToManyTable(b: MigrationBuilder, tableName: string, table1: string, table2: string, options?: TableOptions & DropOptions): void;
+declare function createManyToManyTable(b: MigrationBuilder, tableName: string, column1: ManyToManyColumn, column2: ManyToManyColumn, options?: TableOptions & DropOptions): void;
+declare function createManyToManyTable(b: MigrationBuilder, tableName: string, table1: string, column2: ManyToManyColumn, options?: TableOptions & DropOptions): void;
+declare function createManyToManyTable(b: MigrationBuilder, tableName: string, column1: ManyToManyColumn, table2: string, options?: TableOptions & DropOptions): void;
+/** Adds columns + auto-indexes any foreign keys. */
+declare function addColumns(b: MigrationBuilder, tableName: string, columns: ColumnDefinitions): void;
+declare function fail(message?: string): never;
+//#endregion
+export { FieldNameOverrides, RenameRelationOpts, addColumns, addEnumValue, commentData, createCreatedAtFunction, createEntityTable, createEnumTable, createManyToManyTable, createSubTable, createTriggers, createUnnestArraysFunction, createUpdatedAtFunction, enumArrayColumn, fail, foreignKey, renameRelation, unnest_arrays, updateEnumValue };
+//# sourceMappingURL=utils.d.mts.map

package/build/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";;;;;;;;iBAkBgB,kBAAkB,GAAG,kBAAkB,mBAAmB,SAAS;;;;;;;iBAyBnE,eACd,GAAG,kBACH,uBACA,sBACA,SAAS;iBAsBK,gBAAgB,GAAG,kBAAkB,mBAAmB,QAAQ;iBAShE,aAAa,GAAG,kBAAkB,mBAAmB;iBAMrD,gBACd,GAAG,kBACH,mBACA,sBACA;;iBAcc,eAAe,GAAG,kBAAkB;iBAepC,wBAAwB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoC9B;iBAmBG,2BAA2B,GAAG;iBAI9B,wBAAwB,GAAG;KAS/B;EACV;EACA;;KAEG,iBAAiB,QAAQ,oBAAoB,SAAS,KAAK,gCAAgC;iBAChF,WAAW,oBAAoB,MAAM,iBAAiB;KAU1D,qBAAqB,qBAAqB,KAAK;iBAC3C,eAAe,GAAG,kBAAkB,mBAAmB,oBAAoB,MAAM;iBAIjF,YAAY,WAAW;iBAkBvB,gBAAgB,mBAAmB,OAAO,KAAK,+BAA+B;KAazF;;EAEH;;EAEA;;;;;;;;;;;;;;;;;;EAkBA;;;iBAac,sBACd,GAAG,kBACH,mBACA,gBACA,gBACA,UAAU,eAAe;iBAEX,sBACd,GAAG,kBACH,mBACA,SAAS,kBACT,SAAS,kBACT,UAAU,eAAe;iBAEX,sBACd,GAAG,kBACH,mBACA,gBACA,SAAS,kBACT,UAAU,eAAe;iBAEX,sBACd,GAAG,kBACH,mBACA,SAAS,kBACT,gBACA,UAAU,eAAe;;iBA0BX,WAAW,GAAG,kBAAkB,mBAAmB,SAAS;iBAS5D,KAAK"}

package/build/utils.js

@@ -1,142 +1,132 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unnest_arrays = void 0;
-exports.createEntityTable = createEntityTable;
-exports.createSubTable = createSubTable;
-exports.createEnumTable = createEnumTable;
-exports.addEnumValue = addEnumValue;
-exports.updateEnumValue = updateEnumValue;
-exports.createTriggers = createTriggers;
-exports.createUpdatedAtFunction = createUpdatedAtFunction;
-exports.createUnnestArraysFunction = createUnnestArraysFunction;
-exports.createCreatedAtFunction = createCreatedAtFunction;
-exports.foreignKey = foreignKey;
-exports.renameRelation = renameRelation;
-exports.commentData = commentData;
-exports.enumArrayColumn = enumArrayColumn;
-exports.createManyToManyTable = createManyToManyTable;
-exports.addColumns = addColumns;
-exports.fail = fail;
-const node_pg_migrate_1 = require("node-pg-migrate");
-const pluralize_1 = require("pluralize");
+import { PgLiteral } from "node-pg-migrate";
+import pluralize from "pluralize";
+//#region src/utils.ts
+const { singular } = pluralize;
 /**
- * Creates an entity table with our conventions.
- *
- * Specifically an `id` auto-increment column (via a sequence) and `created_at` and `updated_at`
- * columns.
- */
+* Creates an entity table with our conventions.
+*
+* Specifically an `id` auto-increment column (via a sequence) and `created_at` and `updated_at`
+* columns.
+*/
 function createEntityTable(b, tableName, columns) {
-    b.createTable(tableName, {
-        id: "id",
-        ...columns,
-        created_at: { type: "timestamptz", notNull: true },
-        updated_at: { type: "timestamptz", notNull: true },
-    });
-    // Postgres doesn't automatically index foreign keys, so any column def points at
-    // another table, assume we'll be doing a lot of lookups on this column and should fk it.
-    Object.entries(columns).forEach(([name, def]) => {
-        if (typeof def === "object" && def.references) {
-            b.addIndex(tableName, [name], { method: "btree" });
-        }
-    });
-    createTriggers(b, tableName);
+	b.createTable(tableName, {
+		id: "id",
+		...columns,
+		created_at: {
+			type: "timestamptz",
+			notNull: true
+		},
+		updated_at: {
+			type: "timestamptz",
+			notNull: true
+		}
+	});
+	Object.entries(columns).forEach(([name, def]) => {
+		if (typeof def === "object" && def.references) b.addIndex(tableName, [name], { method: "btree" });
+	});
+	createTriggers(b, tableName);
 }
 /**
- * Creates a subtype table using class-per-table inheritance.
- *
- * The subtable will use the base table's id as its identity, and when loading rows of the base
- * type, Joist will automatically stitch together rows across each table into a single instance.
- */
+* Creates a subtype table using class-per-table inheritance.
+*
+* The subtable will use the base table's id as its identity, and when loading rows of the base
+* type, Joist will automatically stitch together rows across each table into a single instance.
+*/
 function createSubTable(b, baseTableName, subTableName, columns) {
-    b.createTable(subTableName, {
-        id: {
-            type: "int",
-            references: `${baseTableName}`,
-            primaryKey: true,
-            deferrable: true,
-            deferred: true,
-            onDelete: "CASCADE",
-        },
-        ...columns,
-    });
-    // Postgres doesn't automatically index foreign keys, so any column def points at
-    // another table, assume we'll be doing a lot of lookups on this column and should fk it.
-    Object.entries(columns).forEach(([name, def]) => {
-        if (typeof def === "object" && def.references) {
-            b.addIndex(subTableName, [name], { method: "btree" });
-        }
-    });
+	b.createTable(subTableName, {
+		id: {
+			type: "int",
+			references: `${baseTableName}`,
+			primaryKey: true,
+			deferrable: true,
+			deferred: true,
+			onDelete: "CASCADE"
+		},
+		...columns
+	});
+	Object.entries(columns).forEach(([name, def]) => {
+		if (typeof def === "object" && def.references) b.addIndex(subTableName, [name], { method: "btree" });
+	});
 }
 function createEnumTable(b, tableName, values) {
-    b.createTable(tableName, {
-        id: "id",
-        code: { type: "text", notNull: true },
-        name: { type: "text", notNull: true },
-    });
-    b.addConstraint(tableName, `${tableName}_unique_enum_code_constraint`, "UNIQUE (code)");
-    values.forEach((value) => addEnumValue(b, tableName, value));
+	b.createTable(tableName, {
+		id: "id",
+		code: {
+			type: "text",
+			notNull: true
+		},
+		name: {
+			type: "text",
+			notNull: true
+		}
+	});
+	b.addConstraint(tableName, `${tableName}_unique_enum_code_constraint`, "UNIQUE (code)");
+	values.forEach((value) => addEnumValue(b, tableName, value));
 }
 function addEnumValue(b, tableName, value) {
-    const [code, name] = value;
-    validateEnumCode(code);
-    b.sql(`INSERT INTO ${tableName} (code, name) VALUES ('${code}', '${name.replace("'", "''")}');`);
+	const [code, name] = value;
+	validateEnumCode(code);
+	b.sql(`INSERT INTO ${tableName} (code, name) VALUES ('${code}', '${name.replace("'", "''")}');`);
 }
 function updateEnumValue(b, tableName, previousCode, value) {
-    const [code, name] = value;
-    validateEnumCode(code);
-    b.sql(`UPDATE ${tableName} SET code ='${code}', name = '${name.replace("'", "''")}' WHERE code = '${previousCode}';`);
+	const [code, name] = value;
+	validateEnumCode(code);
+	b.sql(`UPDATE ${tableName} SET code ='${code}', name = '${name.replace("'", "''")}' WHERE code = '${previousCode}';`);
 }
 function validateEnumCode(code) {
-    const codeRegex = /^[A-Z0-9_]+$/;
-    if (!codeRegex.test(code))
-        throw `ERROR: Invalid enum code specified: ${code}. Codes must match the regex: ${codeRegex}`;
+	const codeRegex = /^[A-Z0-9_]+$/;
+	if (!codeRegex.test(code)) throw `ERROR: Invalid enum code specified: ${code}. Codes must match the regex: ${codeRegex}`;
 }
 /** Makes a trigger to update the `updated_at` column. */
 function createTriggers(b, tableName) {
-    b.createTrigger(tableName, `${tableName}_created_at`, {
-        when: "BEFORE",
-        operation: "INSERT",
-        level: "ROW",
-        function: "trigger_maybe_set_created_at",
-    });
-    b.createTrigger(tableName, `${tableName}_updated_at`, {
-        when: "BEFORE",
-        operation: "UPDATE",
-        level: "ROW",
-        function: "trigger_maybe_set_updated_at",
-    });
+	b.createTrigger(tableName, `${tableName}_created_at`, {
+		when: "BEFORE",
+		operation: "INSERT",
+		level: "ROW",
+		function: "trigger_maybe_set_created_at"
+	});
+	b.createTrigger(tableName, `${tableName}_updated_at`, {
+		when: "BEFORE",
+		operation: "UPDATE",
+		level: "ROW",
+		function: "trigger_maybe_set_updated_at"
+	});
 }
 function createUpdatedAtFunction(b) {
-    b.createFunction("trigger_maybe_set_updated_at", [], { replace: true, language: "plpgsql", returns: "TRIGGER" }, "BEGIN IF NEW.updated_at = OLD.updated_at THEN NEW.updated_at = NOW(); END IF; RETURN NEW; END;");
+	b.createFunction("trigger_maybe_set_updated_at", [], {
+		replace: true,
+		language: "plpgsql",
+		returns: "TRIGGER"
+	}, "BEGIN IF NEW.updated_at = OLD.updated_at THEN NEW.updated_at = NOW(); END IF; RETURN NEW; END;");
 }
 /**
- * Unnests a 2d array like `[[a, b], [c, d]]` into two rows of `[a, b]` and `[c, d]`.
- *
- * This custom function is a key part of Joist's bulk INSERT/UPDATE that sends "all firstNames as
- * a single param", because it lets us support array columns as a single parameter (i.e. an array
- * of arrays).
- *
- * Postgres's built-in `unnest` is too aggressive when flattening, and will unnest the 2d array
- * of `[[a, b], [c, d]]` into four rows of `a`, `b`, `c`, and `d`, which is not what we want.
- *
- * Additionally, Postgres does not support "jagged arrays", i.e. 2D arrays where some
- * sub-arrays are longer than others, e.g. `[[a, b], [c, d, e]]`. Instead, it treats arrays
- * more as the mathematical concept of a matrix, than "a list of lists".
- *
- * To work around this, our PostgresDriver auto-pads all 2D arrays to the same length, by
- * appending `NULL`, and then `unnest_arrays` prunes all `NULL`s from the resulting 1D arrays.
- * See `fillArrayWithNulls`.
- *
- *
- * This means we purposefully do not/cannot support `NULL` values _within_ array columns,
- * i.e. `nick_names=[a, NULL, b]` (without some additional heuristics).
- *
- * That said, we do need to support nullable array columns, i.e. `nick_names=NULL`, which we
- * detect by prefixing an additional marker element to each sub-array that indicates whether the
- * array column is null or not, and then conditionally enabling this with the `nullable=true`
- * param to `unnest_arrays`.
- */
-exports.unnest_arrays = `
+* Unnests a 2d array like `[[a, b], [c, d]]` into two rows of `[a, b]` and `[c, d]`.
+*
+* This custom function is a key part of Joist's bulk INSERT/UPDATE that sends "all firstNames as
+* a single param", because it lets us support array columns as a single parameter (i.e. an array
+* of arrays).
+*
+* Postgres's built-in `unnest` is too aggressive when flattening, and will unnest the 2d array
+* of `[[a, b], [c, d]]` into four rows of `a`, `b`, `c`, and `d`, which is not what we want.
+*
+* Additionally, Postgres does not support "jagged arrays", i.e. 2D arrays where some
+* sub-arrays are longer than others, e.g. `[[a, b], [c, d, e]]`. Instead, it treats arrays
+* more as the mathematical concept of a matrix, than "a list of lists".
+*
+* To work around this, our PostgresDriver auto-pads all 2D arrays to the same length, by
+* appending `NULL`, and then `unnest_arrays` prunes all `NULL`s from the resulting 1D arrays.
+* See `fillArrayWithNulls`.
+*
+*
+* This means we purposefully do not/cannot support `NULL` values _within_ array columns,
+* i.e. `nick_names=[a, NULL, b]` (without some additional heuristics).
+*
+* That said, we do need to support nullable array columns, i.e. `nick_names=NULL`, which we
+* detect by prefixing an additional marker element to each sub-array that indicates whether the
+* array column is null or not, and then conditionally enabling this with the `nullable=true`
+* param to `unnest_arrays`.
+*/
+const unnest_arrays = `
 CREATE OR REPLACE FUNCTION unnest_arrays(arr ANYARRAY, nullable BOOLEAN = false, OUT a ANYARRAY)
   RETURNS SETOF ANYARRAY
   LANGUAGE plpgsql IMMUTABLE STRICT AS
@@ -155,82 +145,109 @@ END
 $func$;
 `;
 function createUnnestArraysFunction(b) {
-    b.sql(exports.unnest_arrays);
+	b.sql(unnest_arrays);
 }
 function createCreatedAtFunction(b) {
-    b.createFunction("trigger_maybe_set_created_at", [], { replace: true, language: "plpgsql", returns: "TRIGGER" }, "BEGIN IF NEW.created_at IS NULL THEN NEW.created_at = NOW(); END IF; IF NEW.updated_at IS NULL THEN NEW.updated_at = NOW(); END IF; RETURN NEW; END;");
+	b.createFunction("trigger_maybe_set_created_at", [], {
+		replace: true,
+		language: "plpgsql",
+		returns: "TRIGGER"
+	}, "BEGIN IF NEW.created_at IS NULL THEN NEW.created_at = NOW(); END IF; IF NEW.updated_at IS NULL THEN NEW.updated_at = NOW(); END IF; RETURN NEW; END;");
 }
 function foreignKey(otherTable, opts) {
-    return {
-        type: "integer",
-        references: otherTable,
-        deferrable: true,
-        deferred: true,
-        ...foreignKeyOptsWithMaybeComment(opts),
-    };
+	return {
+		type: "integer",
+		references: otherTable,
+		deferrable: true,
+		deferred: true,
+		...foreignKeyOptsWithMaybeComment(opts)
+	};
 }
 function renameRelation(b, tableName, columnName, opts) {
-    b.alterColumn(tableName, columnName, foreignKeyOptsWithMaybeComment(opts));
+	b.alterColumn(tableName, columnName, foreignKeyOptsWithMaybeComment(opts));
 }
 function commentData(data, comment) {
-    return `${comment ?? ""}[pg-structure]${JSON.stringify(data)}[/pg-structure]`;
+	return `${comment ?? ""}[pg-structure]${JSON.stringify(data)}[/pg-structure]`;
 }
 function foreignKeyOptsWithMaybeComment(opts) {
-    let { comment, fieldName, otherFieldName, ...rest } = opts;
-    if (fieldName || otherFieldName) {
-        const overrides = { fieldName, otherFieldName };
-        return { ...rest, comment: commentData(overrides, comment) };
-    }
-    else if (comment) {
-        return { ...rest, comment };
-    }
-    else {
-        return rest;
-    }
+	let { comment, fieldName, otherFieldName, ...rest } = opts;
+	if (fieldName || otherFieldName) {
+		const overrides = {
+			fieldName,
+			otherFieldName
+		};
+		return {
+			...rest,
+			comment: commentData(overrides, comment)
+		};
+	} else if (comment) return {
+		...rest,
+		comment
+	};
+	else return rest;
 }
 function enumArrayColumn(enumTable, opts) {
-    // We use `notNull: false` to facilitate adding to tables with existing rows,
-    // but note that we coalesce null to `[]` anyway in the serde logic, so it
-    // doesn't really matter to application logic whether it's notNull or not.
-    return {
-        type: "integer[]",
-        comment: `enum=${enumTable}`,
-        notNull: false,
-        default: node_pg_migrate_1.PgLiteral.create("array[]::integer[]"),
-        ...opts,
-    };
+	return {
+		type: "integer[]",
+		comment: `enum=${enumTable}`,
+		notNull: false,
+		default: PgLiteral.create("array[]::integer[]"),
+		...opts
+	};
 }
 function maybeTableOrColumn(maybeTableOrColumn) {
-    if (typeof maybeTableOrColumn === "string") {
-        return [maybeTableOrColumn, `${(0, pluralize_1.singular)(maybeTableOrColumn)}_id`, undefined];
-    }
-    else {
-        const { table, column, collectionName } = maybeTableOrColumn;
-        return [table, column ?? `${(0, pluralize_1.singular)(table)}_id`, collectionName];
-    }
+	if (typeof maybeTableOrColumn === "string") return [
+		maybeTableOrColumn,
+		`${singular(maybeTableOrColumn)}_id`,
+		void 0
+	];
+	else {
+		const { table, column, collectionName } = maybeTableOrColumn;
+		return [
+			table,
+			column ?? `${singular(table)}_id`,
+			collectionName
+		];
+	}
 }
 function createManyToManyTable(b, tableName, tableOrColumn1, tableOrColumn2, options) {
-    const [table1, column1, otherFieldName1] = maybeTableOrColumn(tableOrColumn1);
-    const [table2, column2, otherFieldName2] = maybeTableOrColumn(tableOrColumn2);
-    b.createTable(tableName, {
-        id: "id",
-        [column1]: foreignKey(table1, { notNull: true, onDelete: "CASCADE", otherFieldName: otherFieldName1 }),
-        [column2]: foreignKey(table2, { notNull: true, onDelete: "CASCADE", otherFieldName: otherFieldName2 }),
-        created_at: { type: "timestamptz", notNull: true, default: b.func("NOW()") },
-    }, options);
-    b.createIndex(tableName, [column1, column2], { unique: true, ifNotExists: options?.ifNotExists });
-    b.createIndex(tableName, [column2]); // Improves lookup performance when querying just column2
+	const [table1, column1, otherFieldName1] = maybeTableOrColumn(tableOrColumn1);
+	const [table2, column2, otherFieldName2] = maybeTableOrColumn(tableOrColumn2);
+	b.createTable(tableName, {
+		id: "id",
+		[column1]: foreignKey(table1, {
+			notNull: true,
+			onDelete: "CASCADE",
+			otherFieldName: otherFieldName1
+		}),
+		[column2]: foreignKey(table2, {
+			notNull: true,
+			onDelete: "CASCADE",
+			otherFieldName: otherFieldName2
+		}),
+		created_at: {
+			type: "timestamptz",
+			notNull: true,
+			default: b.func("NOW()")
+		}
+	}, options);
+	b.createIndex(tableName, [column1, column2], {
+		unique: true,
+		ifNotExists: options?.ifNotExists
+	});
+	b.createIndex(tableName, [column2]);
 }
 /** Adds columns + auto-indexes any foreign keys. */
 function addColumns(b, tableName, columns) {
-    b.addColumns(tableName, columns);
-    Object.entries(columns).forEach(([name, def]) => {
-        if (typeof def === "object" && def.references) {
-            b.addIndex(tableName, [name], { method: "btree" });
-        }
-    });
+	b.addColumns(tableName, columns);
+	Object.entries(columns).forEach(([name, def]) => {
+		if (typeof def === "object" && def.references) b.addIndex(tableName, [name], { method: "btree" });
+	});
 }
 function fail(message) {
-    throw new Error(message || "Failed");
+	throw new Error(message || "Failed");
 }
+//#endregion
+export { addColumns, addEnumValue, commentData, createCreatedAtFunction, createEntityTable, createEnumTable, createManyToManyTable, createSubTable, createTriggers, createUnnestArraysFunction, createUpdatedAtFunction, enumArrayColumn, fail, foreignKey, renameRelation, unnest_arrays, updateEnumValue };
+
 //# sourceMappingURL=utils.js.map