joist-codegen 2.3.0-next.5 → 2.3.0-next.51

package/build/generateEnumFile.js

@@ -1,58 +1,45 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateEnumFile = generateEnumFile;
-const change_case_1 = require("change-case");
-const pluralize_1 = __importDefault(require("pluralize"));
-const ts_poet_1 = require("ts-poet");
-const symbols_1 = require("./symbols");
+import "./config.js";
+import { EnumMetadata } from "./symbols.js";
+import "./index.js";
+import { pascalCase } from "change-case";
+import pluralize from "pluralize";
+import { code } from "ts-poet";
+//#region src/generateEnumFile.ts
 function generateEnumFile(config, enumData, enumName) {
-    const { rows, extraPrimitives } = enumData;
-    const detailsName = `${enumName}Details`;
-    const idType = enumData.idType === "uuid" ? "string" : "number";
-    // Create the `const fooDetails = code -> literal` mapping
-    const detailsDefinition = [
-        `id: ${idType};`,
-        `code: ${enumName};`,
-        "name: string;",
-        ...extraPrimitives.map((primitive) => {
-            // If the extra primitive values are all unique, then allow the type be only that set of values. Otherwise, use `fieldType`
-            const allValues = rows.map((r) => r[primitive.columnName]);
-            const uniqueValues = new Set(allValues);
-            if (uniqueValues.size === allValues.length) {
-                return `${primitive.fieldName}: ${primitive.fieldType === "string" ? `"${allValues.join('" | "')}"` : allValues.join(" | ")};`;
-            }
-            return `${primitive.fieldName}: ${primitive.fieldType};`;
-        }),
-    ].join(" ");
-    return (0, ts_poet_1.code) `
+	const { rows, extraPrimitives } = enumData;
+	const detailsName = `${enumName}Details`;
+	const idType = enumData.idType === "uuid" ? "string" : "number";
+	const detailsDefinition = [
+		`id: ${idType};`,
+		`code: ${enumName};`,
+		"name: string;",
+		...extraPrimitives.map((primitive) => {
+			const allValues = rows.map((r) => r[primitive.columnName]);
+			if (new Set(allValues).size === allValues.length) return `${primitive.fieldName}: ${primitive.fieldType === "string" ? `"${allValues.join("\" | \"")}"` : allValues.join(" | ")};`;
+			return `${primitive.fieldName}: ${primitive.fieldType};`;
+		})
+	].join(" ");
+	return code`
     export enum ${enumName} {
-      ${rows.map((row) => `${(0, change_case_1.pascalCase)(row.code)} = '${row.code}'`).join(",\n")}
+      ${rows.map((row) => `${pascalCase(row.code)} = '${row.code}'`).join(",\n")}
     }
 
     export type ${detailsName} = {${detailsDefinition}};
 
     const details: Record<${enumName}, ${detailsName}> = {
-      ${rows
-        .map((row) => {
-        const code = (0, change_case_1.pascalCase)(row.code);
-        const safeName = row.name.replace(/(["'])/g, "\\$1");
-        const extras = extraPrimitives
-            .map((p) => `${p.fieldName}: ${JSON.stringify(row[p.columnName])}`)
-            .join(", ");
-        const id = enumData.idType === "uuid" ? `"${row.id}"` : row.id;
-        return `[${enumName}.${code}]: { id: ${id}, code: ${enumName}.${code}, name: '${safeName}', ${extras} }`;
-    })
-        .join(",")}
+      ${rows.map((row) => {
+		const code = pascalCase(row.code);
+		const safeName = row.name.replace(/(["'])/g, "\\$1");
+		const extras = extraPrimitives.map((p) => `${p.fieldName}: ${JSON.stringify(row[p.columnName])}`).join(", ");
+		return `[${enumName}.${code}]: { id: ${enumData.idType === "uuid" ? `"${row.id}"` : row.id}, code: ${enumName}.${code}, name: '${safeName}', ${extras} }`;
+	}).join(",")}
     };
     
     export const ${detailsName} = {
-      ${rows.map((row) => `${(0, change_case_1.pascalCase)(row.code)}: details[${enumName}.${(0, change_case_1.pascalCase)(row.code)}]`).join(",")}
+      ${rows.map((row) => `${pascalCase(row.code)}: details[${enumName}.${pascalCase(row.code)}]`).join(",")}
     };
 
-    export const ${(0, pluralize_1.default)(enumName)}: ${symbols_1.EnumMetadata}<${enumName}, ${detailsName}, ${idType}> = {
+    export const ${pluralize(enumName)}: ${EnumMetadata}<${enumName}, ${detailsName}, ${idType}> = {
       name: "${enumName}",
 
       getByCode(code: ${enumName}): ${detailsName} {
@@ -77,4 +64,7 @@ function generateEnumFile(config, enumData, enumName) {
     };
   `;
 }
+//#endregion
+export { generateEnumFile };
+
 //# sourceMappingURL=generateEnumFile.js.map

package/build/generateEnumFile.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateEnumFile.js","sourceRoot":"","sources":["../src/generateEnumFile.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"generateEnumFile.js","names":[],"sources":["../src/generateEnumFile.ts"],"sourcesContent":["import { pascalCase } from \"change-case\";\nimport pluralize from \"pluralize\";\nimport { type Code, code } from \"ts-poet\";\n\nimport { type Config } from \"./config.ts\";\nimport { type EnumTableData } from \"./index.ts\";\nimport { EnumMetadata } from \"./symbols.ts\";\n\nexport function generateEnumFile(config: Config, enumData: EnumTableData, enumName: string): Code {\n  const { rows, extraPrimitives } = enumData;\n  const detailsName = `${enumName}Details`;\n  const idType = enumData.idType === \"uuid\" ? \"string\" : \"number\";\n\n  // Create the `const fooDetails = code -> literal` mapping\n  const detailsDefinition = [\n    `id: ${idType};`,\n    `code: ${enumName};`,\n    \"name: string;\",\n    ...extraPrimitives.map((primitive) => {\n      // If the extra primitive values are all unique, then allow the type be only that set of values. Otherwise, use `fieldType`\n      const allValues = rows.map((r) => r[primitive.columnName]);\n      const uniqueValues = new Set(allValues);\n      if (uniqueValues.size === allValues.length) {\n        return `${primitive.fieldName}: ${\n          primitive.fieldType === \"string\" ? `\"${allValues.join('\" | \"')}\"` : allValues.join(\" | \")\n        };`;\n      }\n      return `${primitive.fieldName}: ${primitive.fieldType};`;\n    }),\n  ].join(\" \");\n\n  return code`\n    export enum ${enumName} {\n      ${rows.map((row) => `${pascalCase(row.code)} = '${row.code}'`).join(\",\\n\")}\n    }\n\n    export type ${detailsName} = {${detailsDefinition}};\n\n    const details: Record<${enumName}, ${detailsName}> = {\n      ${rows\n        .map((row) => {\n          const code = pascalCase(row.code);\n          const safeName = row.name.replace(/([\"'])/g, \"\\\\$1\");\n          const extras = extraPrimitives\n            .map((p) => `${p.fieldName}: ${JSON.stringify((row as any)[p.columnName])}`)\n            .join(\", \");\n          const id = enumData.idType === \"uuid\" ? `\"${row.id}\"` : row.id;\n          return `[${enumName}.${code}]: { id: ${id}, code: ${enumName}.${code}, name: '${safeName}', ${extras} }`;\n        })\n        .join(\",\")}\n    };\n    \n    export const ${detailsName} = {\n      ${rows.map((row) => `${pascalCase(row.code)}: details[${enumName}.${pascalCase(row.code)}]`).join(\",\")}\n    };\n\n    export const ${pluralize(enumName)}: ${EnumMetadata}<${enumName}, ${detailsName}, ${idType}> = {\n      name: \"${enumName}\",\n\n      getByCode(code: ${enumName}): ${detailsName} {\n        return details[code];\n      },\n\n      findByCode(code: string): ${detailsName} | undefined {\n        return details[code as ${enumName}];\n      },\n\n      findById(id: ${idType}): ${detailsName} | undefined {\n        return Object.values(details).find(d => d.id === id);\n      },\n\n      getValues(): ReadonlyArray<${enumName}> {\n        return Object.values(${enumName});\n      },\n\n      getDetails(): ReadonlyArray<${detailsName}> {\n        return Object.values(details);\n      },\n    };\n  `;\n}\n"],"mappings":";;;;;;;AAQA,SAAgB,iBAAiB,QAAgB,UAAyB,UAAwB;CAChG,MAAM,EAAE,MAAM,oBAAoB;CAClC,MAAM,cAAc,GAAG,SAAS;CAChC,MAAM,SAAS,SAAS,WAAW,SAAS,WAAW;CAGvD,MAAM,oBAAoB;EACxB,OAAO,OAAO;EACd,SAAS,SAAS;EAClB;EACA,GAAG,gBAAgB,KAAK,cAAc;GAEpC,MAAM,YAAY,KAAK,KAAK,MAAM,EAAE,UAAU,WAAW;GAEzD,IAAI,IADqB,IAAI,SACd,CAAC,CAAC,SAAS,UAAU,QAClC,OAAO,GAAG,UAAU,UAAU,IAC5B,UAAU,cAAc,WAAW,IAAI,UAAU,KAAK,SAAO,EAAE,KAAK,UAAU,KAAK,KAAK,EACzF;GAEH,OAAO,GAAG,UAAU,UAAU,IAAI,UAAU,UAAU;EACxD,CAAC;CACH,CAAC,CAAC,KAAK,GAAG;CAEV,OAAO,IAAI;kBACK,SAAS;QACnB,KAAK,KAAK,QAAQ,GAAG,WAAW,IAAI,IAAI,EAAE,MAAM,IAAI,KAAK,EAAE,CAAC,CAAC,KAAK,KAAK,EAAE;;;kBAG/D,YAAY,MAAM,kBAAkB;;4BAE1B,SAAS,IAAI,YAAY;QAC7C,KACC,KAAK,QAAQ;EACZ,MAAM,OAAO,WAAW,IAAI,IAAI;EAChC,MAAM,WAAW,IAAI,KAAK,QAAQ,WAAW,MAAM;EACnD,MAAM,SAAS,gBACZ,KAAK,MAAM,GAAG,EAAE,UAAU,IAAI,KAAK,UAAW,IAAY,EAAE,WAAW,GAAG,CAAC,CAC3E,KAAK,IAAI;EAEZ,OAAO,IAAI,SAAS,GAAG,KAAK,WADjB,SAAS,WAAW,SAAS,IAAI,IAAI,GAAG,KAAK,IAAI,GAClB,UAAU,SAAS,GAAG,KAAK,WAAW,SAAS,KAAK,OAAO;CACvG,CAAC,CAAC,CACD,KAAK,GAAG,EAAE;;;mBAGA,YAAY;QACvB,KAAK,KAAK,QAAQ,GAAG,WAAW,IAAI,IAAI,EAAE,YAAY,SAAS,GAAG,WAAW,IAAI,IAAI,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,EAAE;;;mBAG1F,UAAU,QAAQ,EAAE,IAAI,aAAa,GAAG,SAAS,IAAI,YAAY,IAAI,OAAO;eAChF,SAAS;;wBAEA,SAAS,KAAK,YAAY;;;;kCAIhB,YAAY;iCACb,SAAS;;;qBAGrB,OAAO,KAAK,YAAY;;;;mCAIV,SAAS;+BACb,SAAS;;;oCAGJ,YAAY;;;;;AAKhD"}

package/build/generateFactoriesFiles.cjs

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_symbols = require("./symbols.cjs");
+require("./EntityDbMetadata.cjs");
+let change_case = require("change-case");
+let ts_poet = require("ts-poet");
+//#region src/generateFactoriesFiles.ts
+const EntityManager = (0, ts_poet.imp)("t:EntityManager@./entities.ts");
+function generateFactoriesFiles(entities) {
+	return entities.map(({ entity }) => {
+		const name = (0, change_case.pascalCase)(entity.name);
+		const contents = ts_poet.code`
+      export function new${name}(
+        em: ${EntityManager},
+        opts: ${require_symbols.FactoryOpts}<${entity.type}> = {},
+      ): ${require_symbols.DeepNew}<${entity.type}> {
+        return ${require_symbols.newTestInstance}(em, ${entity.typeSymbol}, opts, {});
+      }`;
+		return {
+			name: `./factories/new${entity.name}.ts`,
+			contents,
+			overwrite: false
+		};
+	});
+}
+//#endregion
+exports.generateFactoriesFiles = generateFactoriesFiles;
+
+//# sourceMappingURL=generateFactoriesFiles.cjs.map

package/build/generateFactoriesFiles.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateFactoriesFiles.cjs","names":["imp","pascalCase","FactoryOpts","DeepNew","newTestInstance"],"sources":["../src/generateFactoriesFiles.ts"],"sourcesContent":["import { pascalCase } from \"change-case\";\nimport { type CodegenFile, code, imp } from \"ts-poet\";\n\nimport { type EntityDbMetadata } from \"./EntityDbMetadata.ts\";\nimport { DeepNew, FactoryOpts, newTestInstance } from \"./symbols.ts\";\n\nconst EntityManager = imp(\"t:EntityManager@./entities.ts\");\n\nexport function generateFactoriesFiles(entities: EntityDbMetadata[]): CodegenFile[] {\n  // One-time create an ./factories/newAuthor.ts for each entity\n  return entities.map(({ entity }) => {\n    const name = pascalCase(entity.name);\n    const contents = code`\n      export function new${name}(\n        em: ${EntityManager},\n        opts: ${FactoryOpts}<${entity.type}> = {},\n      ): ${DeepNew}<${entity.type}> {\n        return ${newTestInstance}(em, ${entity.typeSymbol}, opts, {});\n      }`;\n    return { name: `./factories/new${entity.name}.ts`, contents, overwrite: false };\n  });\n}\n"],"mappings":";;;;;;AAMA,MAAM,iBAAA,GAAgBA,QAAAA,IAAAA,CAAI,+BAA+B;AAEzD,SAAgB,uBAAuB,UAA6C;CAElF,OAAO,SAAS,KAAK,EAAE,aAAa;EAClC,MAAM,QAAA,GAAOC,YAAAA,WAAAA,CAAW,OAAO,IAAI;EACnC,MAAM,WAAW,QAAA,IAAI;2BACE,KAAK;cAClB,cAAc;gBACZC,gBAAAA,YAAY,GAAG,OAAO,KAAK;WAChCC,gBAAAA,QAAQ,GAAG,OAAO,KAAK;iBACjBC,gBAAAA,gBAAgB,OAAO,OAAO,WAAW;;EAEtD,OAAO;GAAE,MAAM,kBAAkB,OAAO,KAAK;GAAM;GAAU,WAAW;EAAM;CAChF,CAAC;AACH"}

package/build/generateFactoriesFiles.d.cts

@@ -0,0 +1,7 @@
+import { EntityDbMetadata } from "./EntityDbMetadata.cjs";
+import { CodegenFile } from "ts-poet";
+//#region src/generateFactoriesFiles.d.ts
+declare function generateFactoriesFiles(entities: EntityDbMetadata[]): CodegenFile[];
+//#endregion
+export { generateFactoriesFiles };
+//# sourceMappingURL=generateFactoriesFiles.d.cts.map

package/build/generateFactoriesFiles.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateFactoriesFiles.d.cts","names":[],"sources":["../src/generateFactoriesFiles.ts"],"mappings":";;;iBAQgB,uBAAuB,UAAU,qBAAqB"}

package/build/generateFactoriesFiles.d.mts

@@ -0,0 +1,7 @@
+import { EntityDbMetadata } from "./EntityDbMetadata.mjs";
+import { CodegenFile } from "ts-poet";
+//#region src/generateFactoriesFiles.d.ts
+declare function generateFactoriesFiles(entities: EntityDbMetadata[]): CodegenFile[];
+//#endregion
+export { generateFactoriesFiles };
+//# sourceMappingURL=generateFactoriesFiles.d.mts.map

package/build/generateFactoriesFiles.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateFactoriesFiles.d.mts","names":[],"sources":["../src/generateFactoriesFiles.ts"],"mappings":";;;iBAQgB,uBAAuB,UAAU,qBAAqB"}

package/build/generateFactoriesFiles.js

@@ -1,22 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFactoriesFiles = generateFactoriesFiles;
-const change_case_1 = require("change-case");
-const ts_poet_1 = require("ts-poet");
-const symbols_1 = require("./symbols");
-const EntityManager = (0, ts_poet_1.imp)("t:EntityManager@./entities.ts");
+import { DeepNew, FactoryOpts, newTestInstance } from "./symbols.js";
+import "./EntityDbMetadata.js";
+import { pascalCase } from "change-case";
+import { code, imp } from "ts-poet";
+//#region src/generateFactoriesFiles.ts
+const EntityManager = imp("t:EntityManager@./entities.ts");
 function generateFactoriesFiles(entities) {
-    // One-time create an ./factories/newAuthor.ts for each entity
-    return entities.map(({ entity }) => {
-        const name = (0, change_case_1.pascalCase)(entity.name);
-        const contents = (0, ts_poet_1.code) `
+	return entities.map(({ entity }) => {
+		const name = pascalCase(entity.name);
+		const contents = code`
       export function new${name}(
         em: ${EntityManager},
-        opts: ${symbols_1.FactoryOpts}<${entity.type}> = {},
-      ): ${symbols_1.DeepNew}<${entity.type}> {
-        return ${symbols_1.newTestInstance}(em, ${entity.typeSymbol}, opts, {});
+        opts: ${FactoryOpts}<${entity.type}> = {},
+      ): ${DeepNew}<${entity.type}> {
+        return ${newTestInstance}(em, ${entity.typeSymbol}, opts, {});
       }`;
-        return { name: `./factories/new${entity.name}.ts`, contents, overwrite: false };
-    });
+		return {
+			name: `./factories/new${entity.name}.ts`,
+			contents,
+			overwrite: false
+		};
+	});
 }
+//#endregion
+export { generateFactoriesFiles };
+
 //# sourceMappingURL=generateFactoriesFiles.js.map

package/build/generateFactoriesFiles.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateFactoriesFiles.js","sourceRoot":"","sources":["../src/generateFactoriesFiles.ts"],"names":[],"mappings":";;AAOA,wDAaC;AApBD,6CAAyC;AACzC,qCAAiD;AAEjD,uCAAkE;AAElE,MAAM,aAAa,GAAG,IAAA,aAAG,EAAC,+BAA+B,CAAC,CAAC;AAE3D,SAAgB,sBAAsB,CAAC,QAA4B;IACjE,8DAA8D;IAC9D,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE;QACjC,MAAM,IAAI,GAAG,IAAA,wBAAU,EAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACrC,MAAM,QAAQ,GAAG,IAAA,cAAI,EAAA;2BACE,IAAI;cACjB,aAAa;gBACX,qBAAW,IAAI,MAAM,CAAC,IAAI;WAC/B,iBAAO,IAAI,MAAM,CAAC,IAAI;iBAChB,yBAAe,QAAQ,MAAM,CAAC,UAAU;QACjD,CAAC;QACL,OAAO,EAAE,IAAI,EAAE,kBAAkB,MAAM,CAAC,IAAI,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IAClF,CAAC,CAAC,CAAC;AACL,CAAC"}
+{"version":3,"file":"generateFactoriesFiles.js","names":[],"sources":["../src/generateFactoriesFiles.ts"],"sourcesContent":["import { pascalCase } from \"change-case\";\nimport { type CodegenFile, code, imp } from \"ts-poet\";\n\nimport { type EntityDbMetadata } from \"./EntityDbMetadata.ts\";\nimport { DeepNew, FactoryOpts, newTestInstance } from \"./symbols.ts\";\n\nconst EntityManager = imp(\"t:EntityManager@./entities.ts\");\n\nexport function generateFactoriesFiles(entities: EntityDbMetadata[]): CodegenFile[] {\n  // One-time create an ./factories/newAuthor.ts for each entity\n  return entities.map(({ entity }) => {\n    const name = pascalCase(entity.name);\n    const contents = code`\n      export function new${name}(\n        em: ${EntityManager},\n        opts: ${FactoryOpts}<${entity.type}> = {},\n      ): ${DeepNew}<${entity.type}> {\n        return ${newTestInstance}(em, ${entity.typeSymbol}, opts, {});\n      }`;\n    return { name: `./factories/new${entity.name}.ts`, contents, overwrite: false };\n  });\n}\n"],"mappings":";;;;;AAMA,MAAM,gBAAgB,IAAI,+BAA+B;AAEzD,SAAgB,uBAAuB,UAA6C;CAElF,OAAO,SAAS,KAAK,EAAE,aAAa;EAClC,MAAM,OAAO,WAAW,OAAO,IAAI;EACnC,MAAM,WAAW,IAAI;2BACE,KAAK;cAClB,cAAc;gBACZ,YAAY,GAAG,OAAO,KAAK;WAChC,QAAQ,GAAG,OAAO,KAAK;iBACjB,gBAAgB,OAAO,OAAO,WAAW;;EAEtD,OAAO;GAAE,MAAM,kBAAkB,OAAO,KAAK;GAAM;GAAU,WAAW;EAAM;CAChF,CAAC;AACH"}

package/build/generateFlushFunction.cjs

@@ -0,0 +1,61 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./EntityDbMetadata.cjs");
+require("pg");
+//#region src/generateFlushFunction.ts
+/** Creates a `flush_database` stored procedure to truncate all the tables between tests. */
+async function createFlushFunction(client, db) {
+	const hasAnyNonDeferredFks = db.entities.some((e) => e.nonDeferredFks.length > 0 || e.nonDeferredManyToManyFks.length > 0);
+	if (db.entities.some((e) => e.primaryKey.columnType === "uuid") || hasAnyNonDeferredFks) await client.query(generateExplicitFlushFunction(db));
+	else await client.query(generateSequenceFlushFunction(db));
+}
+/**
+* Explicitly deletes every entity/m2m table in a deterministic order.
+*
+* We do this for schemas with non-deferred foreign keys (order matters)
+* or schemas with UUID id columns.
+*/
+function generateExplicitFlushFunction(db) {
+	const deletes = [...db.joinTables, ...[...db.entities].sort((a, b) => {
+		const x = a.nonDeferredFkOrder;
+		const y = b.nonDeferredFkOrder;
+		if (x !== y) return y - x;
+		const i = a.baseClassName ? 1 : -1;
+		return (b.baseClassName ? 1 : -1) - i;
+	}).map((e) => e.tableName)].flatMap((t) => [`DELETE FROM "${t}";`, `ALTER SEQUENCE IF EXISTS "${t}_id_seq" RESTART WITH 1 INCREMENT BY 1;`]);
+	return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$
+    BEGIN
+      ${[...db.entities.filter((t) => t.nonDeferredFkOrder).flatMap((t) => t.manyToOnes.filter((m2o) => m2o.onDelete !== "SET NULL" && m2o.onDelete !== "CASCADE").filter((m2o) => db.entitiesByName[m2o.otherEntity.name].nonDeferredFkOrder > t.nonDeferredFkOrder).map((m2o) => `UPDATE ${t.tableName} SET "${m2o.columnName}" = NULL;`)), ...deletes].join("\n")}
+    END;
+   $$ LANGUAGE
+    'plpgsql'`;
+}
+/**
+* A cuter/shorter flush that only DELETEs from tables that were inserted into.
+*
+* The difference between this and the explicit-order function should only be
+* noticeable on 100+ table schemas (specifically, on our production app with ~200 tables
+* and ~5,000 tests, it gave an 8% speed-up vs. the "DELETE every table" approach).
+*/
+function generateSequenceFlushFunction(db) {
+	const stableTables = [...Object.values(db.enums).map((e) => e.table.name), ...db.otherTables];
+	return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$
+    DECLARE seq RECORD;
+    BEGIN
+      FOR seq IN
+        SELECT sequencename AS name
+        FROM pg_sequences
+        WHERE schemaname = 'public' AND last_value IS NOT NULL AND sequencename LIKE '%_id_seq' ${stableTables.length === 0 ? "" : `AND sequencename NOT IN (${stableTables.map((t) => `'${t}_id_seq'`).join(", ")})`}
+      LOOP
+        EXECUTE format('DELETE FROM %I', regexp_replace(seq.name, '_id_seq$', ''));
+        EXECUTE format('ALTER SEQUENCE %I RESTART WITH 1', seq.name);
+      END LOOP;
+    END;
+   $$ LANGUAGE
+    'plpgsql'`;
+}
+//#endregion
+exports.createFlushFunction = createFlushFunction;
+exports.generateExplicitFlushFunction = generateExplicitFlushFunction;
+exports.generateSequenceFlushFunction = generateSequenceFlushFunction;
+
+//# sourceMappingURL=generateFlushFunction.cjs.map

package/build/generateFlushFunction.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateFlushFunction.cjs","names":[],"sources":["../src/generateFlushFunction.ts"],"sourcesContent":["import { type Client } from \"pg\";\n\nimport { type DbMetadata } from \"./EntityDbMetadata.ts\";\n\n/** Creates a `flush_database` stored procedure to truncate all the tables between tests. */\nexport async function createFlushFunction(client: Client, db: DbMetadata): Promise<void> {\n  // We only check nonDeferredManyToManyFks here (and not other places) b/c we don't really count/track m2ms\n  // as true FK dependencies -- they would a) always create cycles, and b) it's easiest enough for us to just\n  // always have `flush_database` / `em.flush` delete from m2m tables first, to avoid FK delete constraints\n  // errors when we delete from the main entity tables.\n  //\n  // ...but, because order matters for the m2m tables, then we have to use the `generateExplicitFlushFunction`\n  // instead of the cuter `generateSequenceFlushFunction`.\n  const hasAnyNonDeferredFks = db.entities.some(\n    (e) => e.nonDeferredFks.length > 0 || e.nonDeferredManyToManyFks.length > 0,\n  );\n  const hasAnyNonSequenceIds = db.entities.some((e) => e.primaryKey.columnType === \"uuid\");\n  if (hasAnyNonSequenceIds || hasAnyNonDeferredFks) {\n    await client.query(generateExplicitFlushFunction(db));\n  } else {\n    await client.query(generateSequenceFlushFunction(db));\n  }\n}\n\n/**\n * Explicitly deletes every entity/m2m table in a deterministic order.\n *\n * We do this for schemas with non-deferred foreign keys (order matters)\n * or schemas with UUID id columns.\n */\nexport function generateExplicitFlushFunction(db: DbMetadata): string {\n  // Leave code/enum tables alone\n  const tables = [\n    ...db.joinTables,\n    ...[...db.entities]\n      .sort((a, b) => {\n        // Flush books before authors if it has non-deferred FKs\n        const x = a.nonDeferredFkOrder;\n        const y = b.nonDeferredFkOrder;\n        if (x !== y) {\n          return y - x;\n        }\n        // Flush base tables before sub-tables.\n        const i = a.baseClassName ? 1 : -1;\n        const j = b.baseClassName ? 1 : -1;\n        return j - i;\n      })\n      .map((e) => e.tableName),\n  ];\n\n  // Note that, for whatever reason, doing DELETEs + ALTER SEQUENCEs is dramatically faster than TRUNCATEs.\n  // On even a 40-table schema, TRUNCATEs (either 1 per table or even a single TRUNCATE with all tables) takes\n  // 100s of milliseconds, whereas DELETEs takes single-digit milliseconds and DELETEs + ALTER SEQUENCEs is\n  // 10s of milliseconds.\n  const deletes = tables.flatMap((t) => [\n    `DELETE FROM \"${t}\";`,\n    `ALTER SEQUENCE IF EXISTS \"${t}_id_seq\" RESTART WITH 1 INCREMENT BY 1;`,\n  ]);\n\n  // Create `SET NULLs` in schemas that don't have deferred FKs\n  const setFksNulls = db.entities\n    .filter((t) => t.nonDeferredFkOrder)\n    .flatMap((t) =>\n      t.manyToOnes\n        // These FKs will auto-unset/delete the later row, so don't need explicit unsetting\n        .filter((m2o) => m2o.onDelete !== \"SET NULL\" && m2o.onDelete !== \"CASCADE\")\n        // Look for FKs to tables whose DELETEs come after us\n        .filter((m2o) => db.entitiesByName[m2o.otherEntity.name].nonDeferredFkOrder > t.nonDeferredFkOrder)\n        .map((m2o) => `UPDATE ${t.tableName} SET \"${m2o.columnName}\" = NULL;`),\n    );\n\n  const statements = [...setFksNulls, ...deletes].join(\"\\n\");\n\n  return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$\n    BEGIN\n      ${statements}\n    END;\n   $$ LANGUAGE\n    'plpgsql'`;\n}\n\n/**\n * A cuter/shorter flush that only DELETEs from tables that were inserted into.\n *\n * The difference between this and the explicit-order function should only be\n * noticeable on 100+ table schemas (specifically, on our production app with ~200 tables\n * and ~5,000 tests, it gave an 8% speed-up vs. the \"DELETE every table\" approach).\n */\nexport function generateSequenceFlushFunction(db: DbMetadata): string {\n  const stableTables = [...Object.values(db.enums).map((e) => e.table.name), ...db.otherTables];\n  const maybeSkipStable =\n    stableTables.length === 0 ? \"\" : `AND sequencename NOT IN (${stableTables.map((t) => `'${t}_id_seq'`).join(\", \")})`;\n  return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$\n    DECLARE seq RECORD;\n    BEGIN\n      FOR seq IN\n        SELECT sequencename AS name\n        FROM pg_sequences\n        WHERE schemaname = 'public' AND last_value IS NOT NULL AND sequencename LIKE '%_id_seq' ${maybeSkipStable}\n      LOOP\n        EXECUTE format('DELETE FROM %I', regexp_replace(seq.name, '_id_seq$', ''));\n        EXECUTE format('ALTER SEQUENCE %I RESTART WITH 1', seq.name);\n      END LOOP;\n    END;\n   $$ LANGUAGE\n    'plpgsql'`;\n}\n"],"mappings":";;;;;AAKA,eAAsB,oBAAoB,QAAgB,IAA+B;CAQvF,MAAM,uBAAuB,GAAG,SAAS,MACtC,MAAM,EAAE,eAAe,SAAS,KAAK,EAAE,yBAAyB,SAAS,CAC5E;CAEA,IAD6B,GAAG,SAAS,MAAM,MAAM,EAAE,WAAW,eAAe,MAC1D,KAAK,sBAC1B,MAAM,OAAO,MAAM,8BAA8B,EAAE,CAAC;MAEpD,MAAM,OAAO,MAAM,8BAA8B,EAAE,CAAC;AAExD;;;;;;;AAQA,SAAgB,8BAA8B,IAAwB;CAwBpE,MAAM,UAAU,CArBd,GAAG,GAAG,YACN,GAAG,CAAC,GAAG,GAAG,QAAQ,CAAC,CAChB,MAAM,GAAG,MAAM;EAEd,MAAM,IAAI,EAAE;EACZ,MAAM,IAAI,EAAE;EACZ,IAAI,MAAM,GACR,OAAO,IAAI;EAGb,MAAM,IAAI,EAAE,gBAAgB,IAAI;EAEhC,QADU,EAAE,gBAAgB,IAAI,MACrB;CACb,CAAC,CAAC,CACD,KAAK,MAAM,EAAE,SAAS,CAON,CAAC,CAAC,SAAS,MAAM,CACpC,gBAAgB,EAAE,KAClB,6BAA6B,EAAE,wCACjC,CAAC;CAgBD,OAAO;;QAFY,CAAC,GAXA,GAAG,SACpB,QAAQ,MAAM,EAAE,kBAAkB,CAAC,CACnC,SAAS,MACR,EAAE,WAEC,QAAQ,QAAQ,IAAI,aAAa,cAAc,IAAI,aAAa,SAAS,CAAC,CAE1E,QAAQ,QAAQ,GAAG,eAAe,IAAI,YAAY,KAAK,CAAC,qBAAqB,EAAE,kBAAkB,CAAC,CAClG,KAAK,QAAQ,UAAU,EAAE,UAAU,QAAQ,IAAI,WAAW,UAAU,CAG1C,GAAG,GAAG,OAAO,CAAC,CAAC,KAAK,IAItC,EAAE;;;;AAInB;;;;;;;;AASA,SAAgB,8BAA8B,IAAwB;CACpE,MAAM,eAAe,CAAC,GAAG,OAAO,OAAO,GAAG,KAAK,CAAC,CAAC,KAAK,MAAM,EAAE,MAAM,IAAI,GAAG,GAAG,GAAG,WAAW;CAG5F,OAAO;;;;;;kGADL,aAAa,WAAW,IAAI,KAAK,4BAA4B,aAAa,KAAK,MAAM,IAAI,EAAE,SAAS,CAAC,CAAC,KAAK,IAAI,EAAE,GAOH;;;;;;;;AAQlH"}

package/build/{generateFlushFunction.d.ts → generateFlushFunction.d.cts}

@@ -1,14 +1,15 @@
+import { DbMetadata } from "./EntityDbMetadata.cjs";
 import { Client } from "pg";
-import { DbMetadata } from "./EntityDbMetadata";
+//#region src/generateFlushFunction.d.ts
 /** Creates a `flush_database` stored procedure to truncate all the tables between tests. */
-export declare function createFlushFunction(client: Client, db: DbMetadata): Promise<void>;
+declare function createFlushFunction(client: Client, db: DbMetadata): Promise<void>;
 /**
  * Explicitly deletes every entity/m2m table in a deterministic order.
  *
  * We do this for schemas with non-deferred foreign keys (order matters)
  * or schemas with UUID id columns.
  */
-export declare function generateExplicitFlushFunction(db: DbMetadata): string;
+declare function generateExplicitFlushFunction(db: DbMetadata): string;
 /**
  * A cuter/shorter flush that only DELETEs from tables that were inserted into.
  *
@@ -16,5 +17,7 @@ export declare function generateExplicitFlushFunction(db: DbMetadata): string;
  * noticeable on 100+ table schemas (specifically, on our production app with ~200 tables
  * and ~5,000 tests, it gave an 8% speed-up vs. the "DELETE every table" approach).
  */
-export declare function generateSequenceFlushFunction(db: DbMetadata): string;
-//# sourceMappingURL=generateFlushFunction.d.ts.map
+declare function generateSequenceFlushFunction(db: DbMetadata): string;
+//#endregion
+export { createFlushFunction, generateExplicitFlushFunction, generateSequenceFlushFunction };
+//# sourceMappingURL=generateFlushFunction.d.cts.map

package/build/generateFlushFunction.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateFlushFunction.d.cts","names":[],"sources":["../src/generateFlushFunction.ts"],"mappings":";;;;iBAKsB,oBAAoB,QAAQ,QAAQ,IAAI,aAAa;;;;;;;iBAyB3D,8BAA8B,IAAI;;;;;;;;iBA0DlC,8BAA8B,IAAI"}

package/build/generateFlushFunction.d.mts

@@ -0,0 +1,23 @@
+import { DbMetadata } from "./EntityDbMetadata.mjs";
+import { Client } from "pg";
+//#region src/generateFlushFunction.d.ts
+/** Creates a `flush_database` stored procedure to truncate all the tables between tests. */
+declare function createFlushFunction(client: Client, db: DbMetadata): Promise<void>;
+/**
+ * Explicitly deletes every entity/m2m table in a deterministic order.
+ *
+ * We do this for schemas with non-deferred foreign keys (order matters)
+ * or schemas with UUID id columns.
+ */
+declare function generateExplicitFlushFunction(db: DbMetadata): string;
+/**
+ * A cuter/shorter flush that only DELETEs from tables that were inserted into.
+ *
+ * The difference between this and the explicit-order function should only be
+ * noticeable on 100+ table schemas (specifically, on our production app with ~200 tables
+ * and ~5,000 tests, it gave an 8% speed-up vs. the "DELETE every table" approach).
+ */
+declare function generateSequenceFlushFunction(db: DbMetadata): string;
+//#endregion
+export { createFlushFunction, generateExplicitFlushFunction, generateSequenceFlushFunction };
+//# sourceMappingURL=generateFlushFunction.d.mts.map

package/build/generateFlushFunction.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateFlushFunction.d.mts","names":[],"sources":["../src/generateFlushFunction.ts"],"mappings":";;;;iBAKsB,oBAAoB,QAAQ,QAAQ,IAAI,aAAa;;;;;;;iBAyB3D,8BAA8B,IAAI;;;;;;;;iBA0DlC,8BAA8B,IAAI"}

package/build/generateFlushFunction.js

@@ -1,98 +1,49 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFlushFunction = createFlushFunction;
-exports.generateExplicitFlushFunction = generateExplicitFlushFunction;
-exports.generateSequenceFlushFunction = generateSequenceFlushFunction;
+import "./EntityDbMetadata.js";
+import "pg";
+//#region src/generateFlushFunction.ts
 /** Creates a `flush_database` stored procedure to truncate all the tables between tests. */
 async function createFlushFunction(client, db) {
-    // We only check nonDeferredManyToManyFks here (and not other places) b/c we don't really count/track m2ms
-    // as true FK dependencies -- they would a) always create cycles, and b) it's easiest enough for us to just
-    // always have `flush_database` / `em.flush` delete from m2m tables first, to avoid FK delete constraints
-    // errors when we delete from the main entity tables.
-    //
-    // ...but, because order matters for the m2m tables, then we have to use the `generateExplicitFlushFunction`
-    // instead of the cuter `generateSequenceFlushFunction`.
-    const hasAnyNonDeferredFks = db.entities.some((e) => e.nonDeferredFks.length > 0 || e.nonDeferredManyToManyFks.length > 0);
-    const hasAnyNonSequenceIds = db.entities.some((e) => e.primaryKey.columnType === "uuid");
-    if (hasAnyNonSequenceIds || hasAnyNonDeferredFks) {
-        await client.query(generateExplicitFlushFunction(db));
-    }
-    else {
-        await client.query(generateSequenceFlushFunction(db));
-    }
+	const hasAnyNonDeferredFks = db.entities.some((e) => e.nonDeferredFks.length > 0 || e.nonDeferredManyToManyFks.length > 0);
+	if (db.entities.some((e) => e.primaryKey.columnType === "uuid") || hasAnyNonDeferredFks) await client.query(generateExplicitFlushFunction(db));
+	else await client.query(generateSequenceFlushFunction(db));
 }
 /**
- * Explicitly deletes every entity/m2m table in a deterministic order.
- *
- * We do this for schemas with non-deferred foreign keys (order matters)
- * or schemas with UUID id columns.
- */
+* Explicitly deletes every entity/m2m table in a deterministic order.
+*
+* We do this for schemas with non-deferred foreign keys (order matters)
+* or schemas with UUID id columns.
+*/
 function generateExplicitFlushFunction(db) {
-    // Leave code/enum tables alone
-    const tables = [
-        ...db.joinTables,
-        ...[...db.entities]
-            .sort((a, b) => {
-            // Flush books before authors if it has non-deferred FKs
-            const x = a.nonDeferredFkOrder;
-            const y = b.nonDeferredFkOrder;
-            if (x !== y) {
-                return y - x;
-            }
-            // Flush base tables before sub-tables.
-            const i = a.baseClassName ? 1 : -1;
-            const j = b.baseClassName ? 1 : -1;
-            return j - i;
-        })
-            .map((e) => e.tableName),
-    ];
-    // Note that, for whatever reason, doing DELETEs + ALTER SEQUENCEs is dramatically faster than TRUNCATEs.
-    // On even a 40-table schema, TRUNCATEs (either 1 per table or even a single TRUNCATE with all tables) takes
-    // 100s of milliseconds, whereas DELETEs takes single-digit milliseconds and DELETEs + ALTER SEQUENCEs is
-    // 10s of milliseconds.
-    const deletes = tables.flatMap((t) => [
-        `DELETE FROM "${t}";`,
-        `ALTER SEQUENCE IF EXISTS "${t}_id_seq" RESTART WITH 1 INCREMENT BY 1;`,
-    ]);
-    // Create `SET NULLs` in schemas that don't have deferred FKs
-    const setFksNulls = db.entities
-        .filter((t) => t.nonDeferredFkOrder)
-        .flatMap((t) => t.manyToOnes
-        // These FKs will auto-unset/delete the later row, so don't need explicit unsetting
-        .filter((m2o) => m2o.onDelete !== "SET NULL" && m2o.onDelete !== "CASCADE")
-        // Look for FKs to tables whose DELETEs come after us
-        .filter((m2o) => db.entitiesByName[m2o.otherEntity.name].nonDeferredFkOrder > t.nonDeferredFkOrder)
-        .map((m2o) => `UPDATE ${t.tableName} SET "${m2o.columnName}" = NULL;`));
-    const statements = [...setFksNulls, ...deletes].join("\n");
-    return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$
+	const deletes = [...db.joinTables, ...[...db.entities].sort((a, b) => {
+		const x = a.nonDeferredFkOrder;
+		const y = b.nonDeferredFkOrder;
+		if (x !== y) return y - x;
+		const i = a.baseClassName ? 1 : -1;
+		return (b.baseClassName ? 1 : -1) - i;
+	}).map((e) => e.tableName)].flatMap((t) => [`DELETE FROM "${t}";`, `ALTER SEQUENCE IF EXISTS "${t}_id_seq" RESTART WITH 1 INCREMENT BY 1;`]);
+	return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$
     BEGIN
-      ${statements}
+      ${[...db.entities.filter((t) => t.nonDeferredFkOrder).flatMap((t) => t.manyToOnes.filter((m2o) => m2o.onDelete !== "SET NULL" && m2o.onDelete !== "CASCADE").filter((m2o) => db.entitiesByName[m2o.otherEntity.name].nonDeferredFkOrder > t.nonDeferredFkOrder).map((m2o) => `UPDATE ${t.tableName} SET "${m2o.columnName}" = NULL;`)), ...deletes].join("\n")}
     END;
    $$ LANGUAGE
     'plpgsql'`;
 }
 /**
- * A cuter/shorter flush that only DELETEs from tables that were inserted into.
- *
- * The difference between this and the explicit-order function should only be
- * noticeable on 100+ table schemas (specifically, on our production app with ~200 tables
- * and ~5,000 tests, it gave an 8% speed-up vs. the "DELETE every table" approach).
- */
+* A cuter/shorter flush that only DELETEs from tables that were inserted into.
+*
+* The difference between this and the explicit-order function should only be
+* noticeable on 100+ table schemas (specifically, on our production app with ~200 tables
+* and ~5,000 tests, it gave an 8% speed-up vs. the "DELETE every table" approach).
+*/
 function generateSequenceFlushFunction(db) {
-    const stableTables = [
-        ...Object.values(db.enums).map((e) => e.table.name),
-        ...db.otherTables,
-    ];
-    const maybeSkipStable = stableTables.length === 0
-        ? ""
-        : `AND sequencename NOT IN (${stableTables.map((t) => `'${t}_id_seq'`).join(", ")})`;
-    return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$
+	const stableTables = [...Object.values(db.enums).map((e) => e.table.name), ...db.otherTables];
+	return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$
     DECLARE seq RECORD;
     BEGIN
       FOR seq IN
         SELECT sequencename AS name
         FROM pg_sequences
-        WHERE schemaname = 'public' AND last_value IS NOT NULL AND sequencename LIKE '%_id_seq' ${maybeSkipStable}
+        WHERE schemaname = 'public' AND last_value IS NOT NULL AND sequencename LIKE '%_id_seq' ${stableTables.length === 0 ? "" : `AND sequencename NOT IN (${stableTables.map((t) => `'${t}_id_seq'`).join(", ")})`}
       LOOP
         EXECUTE format('DELETE FROM %I', regexp_replace(seq.name, '_id_seq$', ''));
         EXECUTE format('ALTER SEQUENCE %I RESTART WITH 1', seq.name);
@@ -101,4 +52,7 @@ function generateSequenceFlushFunction(db) {
    $$ LANGUAGE
     'plpgsql'`;
 }
+//#endregion
+export { createFlushFunction, generateExplicitFlushFunction, generateSequenceFlushFunction };
+
 //# sourceMappingURL=generateFlushFunction.js.map

package/build/generateFlushFunction.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateFlushFunction.js","sourceRoot":"","sources":["../src/generateFlushFunction.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"generateFlushFunction.js","names":[],"sources":["../src/generateFlushFunction.ts"],"sourcesContent":["import { type Client } from \"pg\";\n\nimport { type DbMetadata } from \"./EntityDbMetadata.ts\";\n\n/** Creates a `flush_database` stored procedure to truncate all the tables between tests. */\nexport async function createFlushFunction(client: Client, db: DbMetadata): Promise<void> {\n  // We only check nonDeferredManyToManyFks here (and not other places) b/c we don't really count/track m2ms\n  // as true FK dependencies -- they would a) always create cycles, and b) it's easiest enough for us to just\n  // always have `flush_database` / `em.flush` delete from m2m tables first, to avoid FK delete constraints\n  // errors when we delete from the main entity tables.\n  //\n  // ...but, because order matters for the m2m tables, then we have to use the `generateExplicitFlushFunction`\n  // instead of the cuter `generateSequenceFlushFunction`.\n  const hasAnyNonDeferredFks = db.entities.some(\n    (e) => e.nonDeferredFks.length > 0 || e.nonDeferredManyToManyFks.length > 0,\n  );\n  const hasAnyNonSequenceIds = db.entities.some((e) => e.primaryKey.columnType === \"uuid\");\n  if (hasAnyNonSequenceIds || hasAnyNonDeferredFks) {\n    await client.query(generateExplicitFlushFunction(db));\n  } else {\n    await client.query(generateSequenceFlushFunction(db));\n  }\n}\n\n/**\n * Explicitly deletes every entity/m2m table in a deterministic order.\n *\n * We do this for schemas with non-deferred foreign keys (order matters)\n * or schemas with UUID id columns.\n */\nexport function generateExplicitFlushFunction(db: DbMetadata): string {\n  // Leave code/enum tables alone\n  const tables = [\n    ...db.joinTables,\n    ...[...db.entities]\n      .sort((a, b) => {\n        // Flush books before authors if it has non-deferred FKs\n        const x = a.nonDeferredFkOrder;\n        const y = b.nonDeferredFkOrder;\n        if (x !== y) {\n          return y - x;\n        }\n        // Flush base tables before sub-tables.\n        const i = a.baseClassName ? 1 : -1;\n        const j = b.baseClassName ? 1 : -1;\n        return j - i;\n      })\n      .map((e) => e.tableName),\n  ];\n\n  // Note that, for whatever reason, doing DELETEs + ALTER SEQUENCEs is dramatically faster than TRUNCATEs.\n  // On even a 40-table schema, TRUNCATEs (either 1 per table or even a single TRUNCATE with all tables) takes\n  // 100s of milliseconds, whereas DELETEs takes single-digit milliseconds and DELETEs + ALTER SEQUENCEs is\n  // 10s of milliseconds.\n  const deletes = tables.flatMap((t) => [\n    `DELETE FROM \"${t}\";`,\n    `ALTER SEQUENCE IF EXISTS \"${t}_id_seq\" RESTART WITH 1 INCREMENT BY 1;`,\n  ]);\n\n  // Create `SET NULLs` in schemas that don't have deferred FKs\n  const setFksNulls = db.entities\n    .filter((t) => t.nonDeferredFkOrder)\n    .flatMap((t) =>\n      t.manyToOnes\n        // These FKs will auto-unset/delete the later row, so don't need explicit unsetting\n        .filter((m2o) => m2o.onDelete !== \"SET NULL\" && m2o.onDelete !== \"CASCADE\")\n        // Look for FKs to tables whose DELETEs come after us\n        .filter((m2o) => db.entitiesByName[m2o.otherEntity.name].nonDeferredFkOrder > t.nonDeferredFkOrder)\n        .map((m2o) => `UPDATE ${t.tableName} SET \"${m2o.columnName}\" = NULL;`),\n    );\n\n  const statements = [...setFksNulls, ...deletes].join(\"\\n\");\n\n  return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$\n    BEGIN\n      ${statements}\n    END;\n   $$ LANGUAGE\n    'plpgsql'`;\n}\n\n/**\n * A cuter/shorter flush that only DELETEs from tables that were inserted into.\n *\n * The difference between this and the explicit-order function should only be\n * noticeable on 100+ table schemas (specifically, on our production app with ~200 tables\n * and ~5,000 tests, it gave an 8% speed-up vs. the \"DELETE every table\" approach).\n */\nexport function generateSequenceFlushFunction(db: DbMetadata): string {\n  const stableTables = [...Object.values(db.enums).map((e) => e.table.name), ...db.otherTables];\n  const maybeSkipStable =\n    stableTables.length === 0 ? \"\" : `AND sequencename NOT IN (${stableTables.map((t) => `'${t}_id_seq'`).join(\", \")})`;\n  return `CREATE OR REPLACE FUNCTION flush_database() RETURNS void AS $$\n    DECLARE seq RECORD;\n    BEGIN\n      FOR seq IN\n        SELECT sequencename AS name\n        FROM pg_sequences\n        WHERE schemaname = 'public' AND last_value IS NOT NULL AND sequencename LIKE '%_id_seq' ${maybeSkipStable}\n      LOOP\n        EXECUTE format('DELETE FROM %I', regexp_replace(seq.name, '_id_seq$', ''));\n        EXECUTE format('ALTER SEQUENCE %I RESTART WITH 1', seq.name);\n      END LOOP;\n    END;\n   $$ LANGUAGE\n    'plpgsql'`;\n}\n"],"mappings":";;;;AAKA,eAAsB,oBAAoB,QAAgB,IAA+B;CAQvF,MAAM,uBAAuB,GAAG,SAAS,MACtC,MAAM,EAAE,eAAe,SAAS,KAAK,EAAE,yBAAyB,SAAS,CAC5E;CAEA,IAD6B,GAAG,SAAS,MAAM,MAAM,EAAE,WAAW,eAAe,MAC1D,KAAK,sBAC1B,MAAM,OAAO,MAAM,8BAA8B,EAAE,CAAC;MAEpD,MAAM,OAAO,MAAM,8BAA8B,EAAE,CAAC;AAExD;;;;;;;AAQA,SAAgB,8BAA8B,IAAwB;CAwBpE,MAAM,UAAU,CArBd,GAAG,GAAG,YACN,GAAG,CAAC,GAAG,GAAG,QAAQ,CAAC,CAChB,MAAM,GAAG,MAAM;EAEd,MAAM,IAAI,EAAE;EACZ,MAAM,IAAI,EAAE;EACZ,IAAI,MAAM,GACR,OAAO,IAAI;EAGb,MAAM,IAAI,EAAE,gBAAgB,IAAI;EAEhC,QADU,EAAE,gBAAgB,IAAI,MACrB;CACb,CAAC,CAAC,CACD,KAAK,MAAM,EAAE,SAAS,CAON,CAAC,CAAC,SAAS,MAAM,CACpC,gBAAgB,EAAE,KAClB,6BAA6B,EAAE,wCACjC,CAAC;CAgBD,OAAO;;QAFY,CAAC,GAXA,GAAG,SACpB,QAAQ,MAAM,EAAE,kBAAkB,CAAC,CACnC,SAAS,MACR,EAAE,WAEC,QAAQ,QAAQ,IAAI,aAAa,cAAc,IAAI,aAAa,SAAS,CAAC,CAE1E,QAAQ,QAAQ,GAAG,eAAe,IAAI,YAAY,KAAK,CAAC,qBAAqB,EAAE,kBAAkB,CAAC,CAClG,KAAK,QAAQ,UAAU,EAAE,UAAU,QAAQ,IAAI,WAAW,UAAU,CAG1C,GAAG,GAAG,OAAO,CAAC,CAAC,KAAK,IAItC,EAAE;;;;AAInB;;;;;;;;AASA,SAAgB,8BAA8B,IAAwB;CACpE,MAAM,eAAe,CAAC,GAAG,OAAO,OAAO,GAAG,KAAK,CAAC,CAAC,KAAK,MAAM,EAAE,MAAM,IAAI,GAAG,GAAG,GAAG,WAAW;CAG5F,OAAO;;;;;;kGADL,aAAa,WAAW,IAAI,KAAK,4BAA4B,aAAa,KAAK,MAAM,IAAI,EAAE,SAAS,CAAC,CAAC,KAAK,IAAI,EAAE,GAOH;;;;;;;;AAQlH"}