joist-migration-utils 2.3.0-next.41 → 2.3.0-next.43

package/build/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/build/_virtual/_rolldown/runtime.js

@@ -0,0 +1,5 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __require };

package/build/index.cjs

@@ -0,0 +1,44 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_migrate = require("./migrate.cjs");
+const require_utils = require("./utils.cjs");
+let joist_utils = require("joist-utils");
+let pg = require("pg");
+//#region src/index.ts
+async function joistMigrate() {
+	const client = new pg.Client((0, joist_utils.newPgConnectionConfig)());
+	await client.connect();
+	try {
+		await require_migrate.runMigrationsIfNeeded(client, "./migrations");
+	} finally {
+		await client.end();
+	}
+}
+if (typeof module !== "undefined" && require.main === module) {
+	if (Object.fromEntries === void 0) throw new Error("Joist requires Node v12.4.0+");
+	joistMigrate().catch((err) => {
+		console.error(err);
+		process.exit(1);
+	});
+}
+//#endregion
+exports.addColumns = require_utils.addColumns;
+exports.addEnumValue = require_utils.addEnumValue;
+exports.commentData = require_utils.commentData;
+exports.createCreatedAtFunction = require_utils.createCreatedAtFunction;
+exports.createEntityTable = require_utils.createEntityTable;
+exports.createEnumTable = require_utils.createEnumTable;
+exports.createManyToManyTable = require_utils.createManyToManyTable;
+exports.createSubTable = require_utils.createSubTable;
+exports.createTriggers = require_utils.createTriggers;
+exports.createUnnestArraysFunction = require_utils.createUnnestArraysFunction;
+exports.createUpdatedAtFunction = require_utils.createUpdatedAtFunction;
+exports.enumArrayColumn = require_utils.enumArrayColumn;
+exports.fail = require_utils.fail;
+exports.foreignKey = require_utils.foreignKey;
+exports.joistMigrate = joistMigrate;
+exports.renameRelation = require_utils.renameRelation;
+exports.runMigrationsIfNeeded = require_migrate.runMigrationsIfNeeded;
+exports.unnest_arrays = require_utils.unnest_arrays;
+exports.updateEnumValue = require_utils.updateEnumValue;
+
+//# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["Client","newPgConnectionConfig","runMigrationsIfNeeded"],"sources":["../src/index.ts"],"sourcesContent":["import { newPgConnectionConfig } from \"joist-utils\";\nimport { Client } from \"pg\";\n\nimport { runMigrationsIfNeeded } from \"./migrate.ts\";\n\nexport * from \"./migrate.ts\";\nexport * from \"./utils.ts\";\n\nexport async function joistMigrate(): Promise<void> {\n  const client = new Client(newPgConnectionConfig());\n  await client.connect();\n  try {\n    await runMigrationsIfNeeded(client, \"./migrations\");\n  } finally {\n    await client.end();\n  }\n}\n\n// If we're being run locally.\nif (typeof module !== \"undefined\" && require.main === module) {\n  if (Object.fromEntries === undefined) {\n    throw new Error(\"Joist requires Node v12.4.0+\");\n  }\n  joistMigrate().catch((err) => {\n    console.error(err);\n    process.exit(1);\n  });\n}\n"],"mappings":";;;;;;AAQA,eAAsB,eAA8B;CAClD,MAAM,SAAS,IAAIA,GAAAA,QAAAA,GAAOC,YAAAA,sBAAAA,CAAsB,CAAC;CACjD,MAAM,OAAO,QAAQ;CACrB,IAAI;EACF,MAAMC,gBAAAA,sBAAsB,QAAQ,cAAc;CACpD,UAAU;EACR,MAAM,OAAO,IAAI;CACnB;AACF;AAGA,IAAI,OAAO,WAAW,eAAe,QAAQ,SAAS,QAAQ;CAC5D,IAAI,OAAO,gBAAgB,KAAA,GACzB,MAAM,IAAI,MAAM,8BAA8B;CAEhD,aAAa,CAAC,CAAC,OAAO,QAAQ;EAC5B,QAAQ,MAAM,GAAG;EACjB,QAAQ,KAAK,CAAC;CAChB,CAAC;AACH"}

package/build/index.d.cts

@@ -0,0 +1,7 @@
+import { runMigrationsIfNeeded } from "./migrate.cjs";
+import { FieldNameOverrides, RenameRelationOpts, addColumns, addEnumValue, commentData, createCreatedAtFunction, createEntityTable, createEnumTable, createManyToManyTable, createSubTable, createTriggers, createUnnestArraysFunction, createUpdatedAtFunction, enumArrayColumn, fail, foreignKey, renameRelation, unnest_arrays, updateEnumValue } from "./utils.cjs";
+//#region src/index.d.ts
+declare function joistMigrate(): Promise<void>;
+//#endregion
+export { FieldNameOverrides, RenameRelationOpts, addColumns, addEnumValue, commentData, createCreatedAtFunction, createEntityTable, createEnumTable, createManyToManyTable, createSubTable, createTriggers, createUnnestArraysFunction, createUpdatedAtFunction, enumArrayColumn, fail, foreignKey, joistMigrate, renameRelation, runMigrationsIfNeeded, unnest_arrays, updateEnumValue };
+//# sourceMappingURL=index.d.cts.map

package/build/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;iBAQsB,gBAAgB"}

package/build/index.d.mts

@@ -0,0 +1,7 @@
+import { runMigrationsIfNeeded } from "./migrate.mjs";
+import { FieldNameOverrides, RenameRelationOpts, addColumns, addEnumValue, commentData, createCreatedAtFunction, createEntityTable, createEnumTable, createManyToManyTable, createSubTable, createTriggers, createUnnestArraysFunction, createUpdatedAtFunction, enumArrayColumn, fail, foreignKey, renameRelation, unnest_arrays, updateEnumValue } from "./utils.mjs";
+//#region src/index.d.ts
+declare function joistMigrate(): Promise<void>;
+//#endregion
+export { FieldNameOverrides, RenameRelationOpts, addColumns, addEnumValue, commentData, createCreatedAtFunction, createEntityTable, createEnumTable, createManyToManyTable, createSubTable, createTriggers, createUnnestArraysFunction, createUpdatedAtFunction, enumArrayColumn, fail, foreignKey, joistMigrate, renameRelation, runMigrationsIfNeeded, unnest_arrays, updateEnumValue };
+//# sourceMappingURL=index.d.mts.map

package/build/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;iBAQsB,gBAAgB"}

package/build/index.js

@@ -1,43 +1,26 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.joistMigrate = joistMigrate;
-const joist_utils_1 = require("joist-utils");
-const pg_1 = require("pg");
-const migrate_1 = require("./migrate");
-__exportStar(require("./migrate"), exports);
-__exportStar(require("./utils"), exports);
+import { __require } from "./_virtual/_rolldown/runtime.js";
+import { runMigrationsIfNeeded } from "./migrate.js";
+import { addColumns, addEnumValue, commentData, createCreatedAtFunction, createEntityTable, createEnumTable, createManyToManyTable, createSubTable, createTriggers, createUnnestArraysFunction, createUpdatedAtFunction, enumArrayColumn, fail, foreignKey, renameRelation, unnest_arrays, updateEnumValue } from "./utils.js";
+import { newPgConnectionConfig } from "joist-utils";
+import { Client } from "pg";
+//#region src/index.ts
 async function joistMigrate() {
-    const client = new pg_1.Client((0, joist_utils_1.newPgConnectionConfig)());
-    await client.connect();
-    try {
-        await (0, migrate_1.runMigrationsIfNeeded)(client, "./migrations");
-    }
-    finally {
-        await client.end();
-    }
+	const client = new Client(newPgConnectionConfig());
+	await client.connect();
+	try {
+		await runMigrationsIfNeeded(client, "./migrations");
+	} finally {
+		await client.end();
+	}
 }
-// If we're being run locally.
-if (require.main === module) {
-    if (Object.fromEntries === undefined) {
-        throw new Error("Joist requires Node v12.4.0+");
-    }
-    joistMigrate().catch((err) => {
-        console.error(err);
-        process.exit(1);
-    });
+if (typeof module !== "undefined" && __require.main === module) {
+	if (Object.fromEntries === void 0) throw new Error("Joist requires Node v12.4.0+");
+	joistMigrate().catch((err) => {
+		console.error(err);
+		process.exit(1);
+	});
 }
+//#endregion
+export { addColumns, addEnumValue, commentData, createCreatedAtFunction, createEntityTable, createEnumTable, createManyToManyTable, createSubTable, createTriggers, createUnnestArraysFunction, createUpdatedAtFunction, enumArrayColumn, fail, foreignKey, joistMigrate, renameRelation, runMigrationsIfNeeded, unnest_arrays, updateEnumValue };
+
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,6CAAoD;AACpD,2BAA4B;AAE5B,uCAAkD;AAElD,4CAA0B;AAC1B,0CAAwB;AAEjB,KAAK;IACV,MAAM,MAAM,GAAG,IAAI,WAAM,CAAC,IAAA,mCAAqB,GAAE,CAAC,CAAC;IACnD,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;IACvB,IAAI,CAAC;QACH,MAAM,IAAA,+BAAqB,EAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACtD,CAAC;YAAS,CAAC;QACT,MAAM,MAAM,CAAC,GAAG,EAAE,CAAC;IACrB,CAAC;AACH,CAAC;AAED,8BAA8B;AAC9B,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;IAC5B,IAAI,MAAM,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;IAClD,CAAC;IACD,YAAY,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;QAC3B,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACnB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { newPgConnectionConfig } from \"joist-utils\";\nimport { Client } from \"pg\";\n\nimport { runMigrationsIfNeeded } from \"./migrate.ts\";\n\nexport * from \"./migrate.ts\";\nexport * from \"./utils.ts\";\n\nexport async function joistMigrate(): Promise<void> {\n  const client = new Client(newPgConnectionConfig());\n  await client.connect();\n  try {\n    await runMigrationsIfNeeded(client, \"./migrations\");\n  } finally {\n    await client.end();\n  }\n}\n\n// If we're being run locally.\nif (typeof module !== \"undefined\" && require.main === module) {\n  if (Object.fromEntries === undefined) {\n    throw new Error(\"Joist requires Node v12.4.0+\");\n  }\n  joistMigrate().catch((err) => {\n    console.error(err);\n    process.exit(1);\n  });\n}\n"],"mappings":";;;;;;AAQA,eAAsB,eAA8B;CAClD,MAAM,SAAS,IAAI,OAAO,sBAAsB,CAAC;CACjD,MAAM,OAAO,QAAQ;CACrB,IAAI;EACF,MAAM,sBAAsB,QAAQ,cAAc;CACpD,UAAU;EACR,MAAM,OAAO,IAAI;CACnB;AACF;AAGA,IAAI,OAAO,WAAW,eAAA,UAAuB,SAAS,QAAQ;CAC5D,IAAI,OAAO,gBAAgB,KAAA,GACzB,MAAM,IAAI,MAAM,8BAA8B;CAEhD,aAAa,CAAC,CAAC,OAAO,QAAQ;EAC5B,QAAQ,MAAM,GAAG;EACjB,QAAQ,KAAK,CAAC;CAChB,CAAC;AACH"}

package/build/migrate.cjs

@@ -0,0 +1,20 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("pg");
+let node_pg_migrate = require("node-pg-migrate");
+//#region src/migrate.ts
+const productionDirectory = "/home/node/app/migrations";
+async function runMigrationsIfNeeded(client, dir = productionDirectory) {
+	await (0, node_pg_migrate.runner)({
+		dbClient: client,
+		migrationsTable: "migrations",
+		dir,
+		count: void 0,
+		direction: "up",
+		ignorePattern: "(\\..*)|(.*\\.d\\.ts)|(.*utils\\.[jt]s)|(migrate\\.[jt]s)|(migrate\\.test\\.[jt]s)",
+		decamelize: process.env.DECAMELIZE ? process.env.DECAMELIZE === "true" : true
+	});
+}
+//#endregion
+exports.runMigrationsIfNeeded = runMigrationsIfNeeded;
+
+//# sourceMappingURL=migrate.cjs.map

package/build/migrate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.cjs","names":["runner"],"sources":["../src/migrate.ts"],"sourcesContent":["import { runner } from \"node-pg-migrate\";\nimport { type Client } from \"pg\";\n\nconst productionDirectory = \"/home/node/app/migrations\";\n\nexport async function runMigrationsIfNeeded(client: Client, dir: string = productionDirectory): Promise<void> {\n  await runner({\n    dbClient: client,\n    migrationsTable: \"migrations\",\n    dir,\n    count: undefined as any as number,\n    direction: \"up\",\n    ignorePattern: \"(\\\\..*)|(.*\\\\.d\\\\.ts)|(.*utils\\\\.[jt]s)|(migrate\\\\.[jt]s)|(migrate\\\\.test\\\\.[jt]s)\",\n    // I generally dislike the magic of decamelize, but pragmatically it seems like a good foot-gun\n    // mitigation to keep schemas always underscores/snake-based.\n    // That said, provide an escape hatch, via the DECAMELIZE env var, which we also use for tests\n    // since we want to specifically regression test the behavior of camelCased columns.\n    decamelize: process.env.DECAMELIZE ? process.env.DECAMELIZE === \"true\" : true,\n  });\n}\n"],"mappings":";;;;AAGA,MAAM,sBAAsB;AAE5B,eAAsB,sBAAsB,QAAgB,MAAc,qBAAoC;CAC5G,OAAA,GAAMA,gBAAAA,OAAAA,CAAO;EACX,UAAU;EACV,iBAAiB;EACjB;EACA,OAAO,KAAA;EACP,WAAW;EACX,eAAe;EAKf,YAAY,QAAQ,IAAI,aAAa,QAAQ,IAAI,eAAe,SAAS;CAC3E,CAAC;AACH"}

package/build/migrate.d.cts

@@ -0,0 +1,6 @@
+import { Client } from "pg";
+//#region src/migrate.d.ts
+declare function runMigrationsIfNeeded(client: Client, dir?: string): Promise<void>;
+//#endregion
+export { runMigrationsIfNeeded };
+//# sourceMappingURL=migrate.d.cts.map

package/build/migrate.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.cts","names":[],"sources":["../src/migrate.ts"],"mappings":";;iBAKsB,sBAAsB,QAAQ,QAAQ,eAAoC"}

package/build/migrate.d.mts

@@ -0,0 +1,6 @@
+import { Client } from "pg";
+//#region src/migrate.d.ts
+declare function runMigrationsIfNeeded(client: Client, dir?: string): Promise<void>;
+//#endregion
+export { runMigrationsIfNeeded };
+//# sourceMappingURL=migrate.d.mts.map

package/build/migrate.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.mts","names":[],"sources":["../src/migrate.ts"],"mappings":";;iBAKsB,sBAAsB,QAAQ,QAAQ,eAAoC"}

package/build/migrate.js

@@ -1,21 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runMigrationsIfNeeded = runMigrationsIfNeeded;
-const node_pg_migrate_1 = require("node-pg-migrate");
+import "pg";
+import { runner } from "node-pg-migrate";
+//#region src/migrate.ts
 const productionDirectory = "/home/node/app/migrations";
 async function runMigrationsIfNeeded(client, dir = productionDirectory) {
-    await (0, node_pg_migrate_1.runner)({
-        dbClient: client,
-        migrationsTable: "migrations",
-        dir,
-        count: undefined,
-        direction: "up",
-        ignorePattern: "(\\..*)|(.*\\.d\\.ts)|(.*utils\\.[jt]s)|(migrate\\.[jt]s)|(migrate\\.test\\.[jt]s)",
-        // I generally dislike the magic of decamelize, but pragmatically it seems like a good foot-gun
-        // mitigation to keep schemas always underscores/snake-based.
-        // That said, provide an escape hatch, via the DECAMELIZE env var, which we also use for tests
-        // since we want to specifically regression test the behavior of camelCased columns.
-        decamelize: process.env.DECAMELIZE ? process.env.DECAMELIZE === "true" : true,
-    });
+	await runner({
+		dbClient: client,
+		migrationsTable: "migrations",
+		dir,
+		count: void 0,
+		direction: "up",
+		ignorePattern: "(\\..*)|(.*\\.d\\.ts)|(.*utils\\.[jt]s)|(migrate\\.[jt]s)|(migrate\\.test\\.[jt]s)",
+		decamelize: process.env.DECAMELIZE ? process.env.DECAMELIZE === "true" : true
+	});
 }
+//#endregion
+export { runMigrationsIfNeeded };
+
 //# sourceMappingURL=migrate.js.map

package/build/migrate.js.map

@@ -1 +1 @@
-{"version":3,"file":"migrate.js","sourceRoot":"","sources":["../src/migrate.ts"],"names":[],"mappings":";;;AAAA,qDAAyC;AAGzC,MAAM,mBAAmB,GAAG,2BAA2B,CAAC;AAEjD,KAAK,gCAAgC,MAAc,EAAE,GAAG,GAAW,mBAAmB;IAC3F,MAAM,IAAA,wBAAM,EAAC;QACX,QAAQ,EAAE,MAAM;QAChB,eAAe,EAAE,YAAY;QAC7B,GAAG;QACH,KAAK,EAAE,SAA0B;QACjC,SAAS,EAAE,IAAI;QACf,aAAa,EAAE,oFAAoF;QACnG,+FAA+F;QAC/F,6DAA6D;QAC7D,8FAA8F;QAC9F,oFAAoF;QACpF,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI;KAC9E,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"migrate.js","names":[],"sources":["../src/migrate.ts"],"sourcesContent":["import { runner } from \"node-pg-migrate\";\nimport { type Client } from \"pg\";\n\nconst productionDirectory = \"/home/node/app/migrations\";\n\nexport async function runMigrationsIfNeeded(client: Client, dir: string = productionDirectory): Promise<void> {\n  await runner({\n    dbClient: client,\n    migrationsTable: \"migrations\",\n    dir,\n    count: undefined as any as number,\n    direction: \"up\",\n    ignorePattern: \"(\\\\..*)|(.*\\\\.d\\\\.ts)|(.*utils\\\\.[jt]s)|(migrate\\\\.[jt]s)|(migrate\\\\.test\\\\.[jt]s)\",\n    // I generally dislike the magic of decamelize, but pragmatically it seems like a good foot-gun\n    // mitigation to keep schemas always underscores/snake-based.\n    // That said, provide an escape hatch, via the DECAMELIZE env var, which we also use for tests\n    // since we want to specifically regression test the behavior of camelCased columns.\n    decamelize: process.env.DECAMELIZE ? process.env.DECAMELIZE === \"true\" : true,\n  });\n}\n"],"mappings":";;;AAGA,MAAM,sBAAsB;AAE5B,eAAsB,sBAAsB,QAAgB,MAAc,qBAAoC;CAC5G,MAAM,OAAO;EACX,UAAU;EACV,iBAAiB;EACjB;EACA,OAAO,KAAA;EACP,WAAW;EACX,eAAe;EAKf,YAAY,QAAQ,IAAI,aAAa,QAAQ,IAAI,eAAe,SAAS;CAC3E,CAAC;AACH"}

package/build/utils.cjs

@@ -0,0 +1,272 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+let node_pg_migrate = require("node-pg-migrate");
+let pluralize = require("pluralize");
+pluralize = require_runtime.__toESM(pluralize, 1);
+//#region src/utils.ts
+const { singular } = pluralize.default;
+/**
+* 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
+		}
+	});
+	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.
+*/
+function createSubTable(b, baseTableName, subTableName, columns) {
+	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));
+}
+function addEnumValue(b, tableName, value) {
+	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}';`);
+}
+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}`;
+}
+/** 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"
+	});
+}
+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;");
+}
+/**
+* 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
+$func$
+BEGIN
+  FOREACH a SLICE 1 IN ARRAY arr LOOP
+    IF nullable THEN
+      IF a[1] IS NULL THEN a := NULL;
+      ELSE a := a[2:array_length(a, 1)];
+      END IF;
+    END IF;
+    a := array_remove(a, NULL);
+    RETURN NEXT;
+  END LOOP;
+END
+$func$;
+`;
+function createUnnestArraysFunction(b) {
+	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;");
+}
+function foreignKey(otherTable, opts) {
+	return {
+		type: "integer",
+		references: otherTable,
+		deferrable: true,
+		deferred: true,
+		...foreignKeyOptsWithMaybeComment(opts)
+	};
+}
+function renameRelation(b, tableName, columnName, opts) {
+	b.alterColumn(tableName, columnName, foreignKeyOptsWithMaybeComment(opts));
+}
+function commentData(data, comment) {
+	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;
+}
+function enumArrayColumn(enumTable, opts) {
+	return {
+		type: "integer[]",
+		comment: `enum=${enumTable}`,
+		notNull: false,
+		default: node_pg_migrate.PgLiteral.create("array[]::integer[]"),
+		...opts
+	};
+}
+function maybeTableOrColumn(maybeTableOrColumn) {
+	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]);
+}
+/** 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" });
+	});
+}
+function fail(message) {
+	throw new Error(message || "Failed");
+}
+//#endregion
+exports.addColumns = addColumns;
+exports.addEnumValue = addEnumValue;
+exports.commentData = commentData;
+exports.createCreatedAtFunction = createCreatedAtFunction;
+exports.createEntityTable = createEntityTable;
+exports.createEnumTable = createEnumTable;
+exports.createManyToManyTable = createManyToManyTable;
+exports.createSubTable = createSubTable;
+exports.createTriggers = createTriggers;
+exports.createUnnestArraysFunction = createUnnestArraysFunction;
+exports.createUpdatedAtFunction = createUpdatedAtFunction;
+exports.enumArrayColumn = enumArrayColumn;
+exports.fail = fail;
+exports.foreignKey = foreignKey;
+exports.renameRelation = renameRelation;
+exports.unnest_arrays = unnest_arrays;
+exports.updateEnumValue = updateEnumValue;
+
+//# sourceMappingURL=utils.cjs.map

package/build/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":["PgLiteral"],"sources":["../src/utils.ts"],"sourcesContent":["import {\n  type ColumnDefinition,\n  type ColumnDefinitions,\n  type DropOptions,\n  type MigrationBuilder,\n  PgLiteral,\n  type TableOptions,\n} from \"node-pg-migrate\";\nimport pluralize from \"pluralize\";\n\nconst { singular } = pluralize;\n\n/**\n * Creates an entity table with our conventions.\n *\n * Specifically an `id` auto-increment column (via a sequence) and `created_at` and `updated_at`\n * columns.\n */\nexport function createEntityTable(b: MigrationBuilder, tableName: string, columns: ColumnDefinitions): void {\n  b.createTable(tableName, {\n    id: \"id\",\n    ...columns,\n    created_at: { type: \"timestamptz\", notNull: true },\n    updated_at: { type: \"timestamptz\", notNull: true },\n  });\n\n  // Postgres doesn't automatically index foreign keys, so any column def points at\n  // another table, assume we'll be doing a lot of lookups on this column and should fk it.\n  Object.entries(columns).forEach(([name, def]) => {\n    if (typeof def === \"object\" && def.references) {\n      b.addIndex(tableName, [name], { method: \"btree\" });\n    }\n  });\n\n  createTriggers(b, tableName);\n}\n\n/**\n * Creates a subtype table using class-per-table inheritance.\n *\n * The subtable will use the base table's id as its identity, and when loading rows of the base\n * type, Joist will automatically stitch together rows across each table into a single instance.\n */\nexport function createSubTable(\n  b: MigrationBuilder,\n  baseTableName: string,\n  subTableName: string,\n  columns: ColumnDefinitions,\n): void {\n  b.createTable(subTableName, {\n    id: {\n      type: \"int\",\n      references: `${baseTableName}`,\n      primaryKey: true,\n      deferrable: true,\n      deferred: true,\n      onDelete: \"CASCADE\",\n    },\n    ...columns,\n  });\n  // Postgres doesn't automatically index foreign keys, so any column def points at\n  // another table, assume we'll be doing a lot of lookups on this column and should fk it.\n  Object.entries(columns).forEach(([name, def]) => {\n    if (typeof def === \"object\" && def.references) {\n      b.addIndex(subTableName, [name], { method: \"btree\" });\n    }\n  });\n}\n\nexport function createEnumTable(b: MigrationBuilder, tableName: string, values: Array<[string, string]>): void {\n  b.createTable(tableName, {\n    id: \"id\",\n    code: { type: \"text\", notNull: true },\n    name: { type: \"text\", notNull: true },\n  });\n  b.addConstraint(tableName, `${tableName}_unique_enum_code_constraint`, \"UNIQUE (code)\");\n  values.forEach((value) => addEnumValue(b, tableName, value));\n}\nexport function addEnumValue(b: MigrationBuilder, tableName: string, value: [string, string]): void {\n  const [code, name] = value;\n  validateEnumCode(code);\n  b.sql(`INSERT INTO ${tableName} (code, name) VALUES ('${code}', '${name.replace(\"'\", \"''\")}');`);\n}\n\nexport function updateEnumValue(\n  b: MigrationBuilder,\n  tableName: string,\n  previousCode: string,\n  value: [string, string],\n): void {\n  const [code, name] = value;\n  validateEnumCode(code);\n  b.sql(`UPDATE ${tableName} SET code ='${code}', name = '${name.replace(\"'\", \"''\")}' WHERE code = '${previousCode}';`);\n}\n\nfunction validateEnumCode(code: string): void {\n  const codeRegex = /^[A-Z0-9_]+$/;\n  if (!codeRegex.test(code))\n    throw `ERROR: Invalid enum code specified: ${code}. Codes must match the regex: ${codeRegex}`;\n}\n\n/** Makes a trigger to update the `updated_at` column. */\nexport function createTriggers(b: MigrationBuilder, tableName: string): void {\n  b.createTrigger(tableName, `${tableName}_created_at`, {\n    when: \"BEFORE\",\n    operation: \"INSERT\",\n    level: \"ROW\",\n    function: \"trigger_maybe_set_created_at\",\n  });\n  b.createTrigger(tableName, `${tableName}_updated_at`, {\n    when: \"BEFORE\",\n    operation: \"UPDATE\",\n    level: \"ROW\",\n    function: \"trigger_maybe_set_updated_at\",\n  });\n}\n\nexport function createUpdatedAtFunction(b: MigrationBuilder): void {\n  b.createFunction(\n    \"trigger_maybe_set_updated_at\",\n    [],\n    { replace: true, language: \"plpgsql\", returns: \"TRIGGER\" },\n    \"BEGIN IF NEW.updated_at = OLD.updated_at THEN NEW.updated_at = NOW(); END IF; RETURN NEW; END;\",\n  );\n}\n\n/**\n * Unnests a 2d array like `[[a, b], [c, d]]` into two rows of `[a, b]` and `[c, d]`.\n *\n * This custom function is a key part of Joist's bulk INSERT/UPDATE that sends \"all firstNames as\n * a single param\", because it lets us support array columns as a single parameter (i.e. an array\n * of arrays).\n *\n * Postgres's built-in `unnest` is too aggressive when flattening, and will unnest the 2d array\n * of `[[a, b], [c, d]]` into four rows of `a`, `b`, `c`, and `d`, which is not what we want.\n *\n * Additionally, Postgres does not support \"jagged arrays\", i.e. 2D arrays where some\n * sub-arrays are longer than others, e.g. `[[a, b], [c, d, e]]`. Instead, it treats arrays\n * more as the mathematical concept of a matrix, than \"a list of lists\".\n *\n * To work around this, our PostgresDriver auto-pads all 2D arrays to the same length, by\n * appending `NULL`, and then `unnest_arrays` prunes all `NULL`s from the resulting 1D arrays.\n * See `fillArrayWithNulls`.\n *\n *\n * This means we purposefully do not/cannot support `NULL` values _within_ array columns,\n * i.e. `nick_names=[a, NULL, b]` (without some additional heuristics).\n *\n * That said, we do need to support nullable array columns, i.e. `nick_names=NULL`, which we\n * detect by prefixing an additional marker element to each sub-array that indicates whether the\n * array column is null or not, and then conditionally enabling this with the `nullable=true`\n * param to `unnest_arrays`.\n */\nexport 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`;\n\nexport function createUnnestArraysFunction(b: MigrationBuilder): void {\n  b.sql(unnest_arrays);\n}\n\nexport function createCreatedAtFunction(b: MigrationBuilder): void {\n  b.createFunction(\n    \"trigger_maybe_set_created_at\",\n    [],\n    { replace: true, language: \"plpgsql\", returns: \"TRIGGER\" },\n    \"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;\",\n  );\n}\n\nexport type FieldNameOverrides = {\n  fieldName?: string;\n  otherFieldName?: string;\n};\ntype ForeignKeyOpts = Partial<ColumnDefinition> & Required<Pick<ColumnDefinition, \"notNull\">> & FieldNameOverrides;\nexport function foreignKey(otherTable: string, opts: ForeignKeyOpts): ColumnDefinition {\n  return {\n    type: \"integer\",\n    references: otherTable,\n    deferrable: true,\n    deferred: true,\n    ...foreignKeyOptsWithMaybeComment(opts),\n  };\n}\n\nexport type RenameRelationOpts = FieldNameOverrides & Pick<ColumnDefinition, \"comment\">;\nexport function renameRelation(b: MigrationBuilder, tableName: string, columnName: string, opts: RenameRelationOpts) {\n  b.alterColumn(tableName, columnName, foreignKeyOptsWithMaybeComment(opts));\n}\n\nexport function commentData(data: any, comment?: string | null): string {\n  return `${comment ?? \"\"}[pg-structure]${JSON.stringify(data)}[/pg-structure]`;\n}\n\nfunction foreignKeyOptsWithMaybeComment<T extends RenameRelationOpts, R extends Omit<T, keyof FieldNameOverrides>>(\n  opts: T,\n): R {\n  let { comment, fieldName, otherFieldName, ...rest } = opts;\n  if (fieldName || otherFieldName) {\n    const overrides = { fieldName, otherFieldName };\n    return { ...(rest as R), comment: commentData(overrides, comment) };\n  } else if (comment) {\n    return { ...(rest as R), comment };\n  } else {\n    return rest as R;\n  }\n}\n\nexport function enumArrayColumn(enumTable: string, opts?: Pick<ColumnDefinition, \"notNull\">): ColumnDefinition {\n  // We use `notNull: false` to facilitate adding to tables with existing rows,\n  // but note that we coalesce null to `[]` anyway in the serde logic, so it\n  // doesn't really matter to application logic whether it's notNull or not.\n  return {\n    type: \"integer[]\",\n    comment: `enum=${enumTable}`,\n    notNull: false,\n    default: PgLiteral.create(\"array[]::integer[]\"),\n    ...opts,\n  };\n}\n\ntype ManyToManyColumn = {\n  /** The target table for this m2m table, i.e. for a `books_to_tags`, this might be `books`. */\n  table: string;\n  /** The column name within the m2m table, i.e. for a `books_to_tags`, this might be `book_id`. */\n  column?: string;\n  /**\n   * The name of the collection that *points to* these rows, i.e. for `books_to_tags` and the `book_id`\n   * column, `collectionName=taggedBooks` b/c `t1.taggedBooks` does a `SELECT book_id WHERE tag_id=t:1`.\n   *\n   * For self-referential m2m tables, i.e. `author_to_mentors`, these names can be confusing, i.e.:\n   *\n   * ```\n   * createManyToManyTable(\n   *   b,\n   *   \"author_to_mentors\",\n   *   // column=mentor_id, collectionName=mentors ==> `a.mentors` does `select mentor_id WHERE mentee_id=a:1`\n   *   { table: \"authors\", column: \"mentor_id\", collectionName: \"mentors\" },\n   *   // column=mentee_id, collectionName=mentees ==> `a.mentees` does `select mentee_id WHERE mentor_id=a:1`\n   *   { table: \"authors\", column: \"mentee_id\", collectionName: \"mentees\" },\n   * );\n   * ````\n   */\n  collectionName?: string;\n};\n\nfunction maybeTableOrColumn(maybeTableOrColumn: string | ManyToManyColumn): [string, string, string | undefined] {\n  if (typeof maybeTableOrColumn === \"string\") {\n    return [maybeTableOrColumn, `${singular(maybeTableOrColumn)}_id`, undefined];\n  } else {\n    const { table, column, collectionName } = maybeTableOrColumn;\n    return [table, column ?? `${singular(table)}_id`, collectionName];\n  }\n}\n\n/** Creates a many-to-many table between `table1` and `table2` with our conventions. */\nexport function createManyToManyTable(\n  b: MigrationBuilder,\n  tableName: string,\n  table1: string,\n  table2: string,\n  options?: TableOptions & DropOptions,\n): void;\nexport function createManyToManyTable(\n  b: MigrationBuilder,\n  tableName: string,\n  column1: ManyToManyColumn,\n  column2: ManyToManyColumn,\n  options?: TableOptions & DropOptions,\n): void;\nexport function createManyToManyTable(\n  b: MigrationBuilder,\n  tableName: string,\n  table1: string,\n  column2: ManyToManyColumn,\n  options?: TableOptions & DropOptions,\n): void;\nexport function createManyToManyTable(\n  b: MigrationBuilder,\n  tableName: string,\n  column1: ManyToManyColumn,\n  table2: string,\n  options?: TableOptions & DropOptions,\n): void;\nexport function createManyToManyTable(\n  b: MigrationBuilder,\n  tableName: string,\n  tableOrColumn1: string | ManyToManyColumn,\n  tableOrColumn2: string | ManyToManyColumn,\n  options?: TableOptions & DropOptions,\n) {\n  const [table1, column1, otherFieldName1] = maybeTableOrColumn(tableOrColumn1);\n  const [table2, column2, otherFieldName2] = maybeTableOrColumn(tableOrColumn2);\n  b.createTable(\n    tableName,\n    {\n      id: \"id\",\n      [column1]: foreignKey(table1, { notNull: true, onDelete: \"CASCADE\", otherFieldName: otherFieldName1 }),\n      [column2]: foreignKey(table2, { notNull: true, onDelete: \"CASCADE\", otherFieldName: otherFieldName2 }),\n      created_at: { type: \"timestamptz\", notNull: true, default: b.func(\"NOW()\") },\n    },\n    options,\n  );\n  b.createIndex(tableName, [column1, column2], { unique: true, ifNotExists: options?.ifNotExists });\n  b.createIndex(tableName, [column2]); // Improves lookup performance when querying just column2\n}\n\n/** Adds columns + auto-indexes any foreign keys. */\nexport function addColumns(b: MigrationBuilder, tableName: string, columns: ColumnDefinitions): void {\n  b.addColumns(tableName, columns);\n  Object.entries(columns).forEach(([name, def]) => {\n    if (typeof def === \"object\" && def.references) {\n      b.addIndex(tableName, [name], { method: \"btree\" });\n    }\n  });\n}\n\nexport function fail(message?: string): never {\n  throw new Error(message || \"Failed\");\n}\n"],"mappings":"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"}