joist-codegen 2.3.0-next.9 → 2.3.0-next.90

package/build/scanEntityFiles.cjs

@@ -0,0 +1,46 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./config.cjs");
+require("./EntityDbMetadata.cjs");
+let path = require("path");
+let fs_promises = require("fs/promises");
+//#region src/scanEntityFiles.ts
+const regex = /config\.setDefault\([\s\n]*["'](\w+)["']/g;
+/** Scans the entity files themselves for usage hints (like `setDefault` calls) to drive our codegen output. */
+async function scanEntityFiles(config, dbMeta) {
+	await Promise.all(dbMeta.entities.map(async (entity) => {
+		try {
+			const tsCode = (await (0, fs_promises.readFile)((0, path.join)(config.entitiesDirectory, `${entity.name}.ts`))).toString();
+			const defaultableFields = recursiveDefaultableFields(dbMeta, entity);
+			for (const match of tsCode.matchAll(regex)) {
+				const field = defaultableFields.find((f) => f.fieldName === match[1]);
+				if (field) field.hasConfigDefault = true;
+			}
+		} catch (e) {}
+	}));
+}
+/**
+* Traverse the entity inheritance tree to find all fields that can have defaults set on them.
+*
+* I.e. a column defined in a base CTI table like `publishers.foo_bar` having a `config.setDefault` in
+* `SmallPublisher` and/or `LargePublisher`, or the same scenario for an STI table like `tasks.foo_bar`
+* with `TaskNew` and/or `TaskOld`.
+*
+* NOTE: I suspect here could be some edge cases here that will need to be ironed out, but should work
+* for simple inheritance structures. In particular, there may be unexpected side effects if a base
+* class field has a default set in one subtype, but not another.
+*/
+function recursiveDefaultableFields(dbMeta, entity) {
+	if (!entity) return [];
+	return [
+		...entity.primitives,
+		...entity.enums,
+		...entity.pgEnums,
+		...entity.manyToOnes,
+		...entity.polymorphics,
+		...entity.baseClassName ? recursiveDefaultableFields(dbMeta, dbMeta.entitiesByName[entity.baseClassName]) : []
+	];
+}
+//#endregion
+exports.scanEntityFiles = scanEntityFiles;
+
+//# sourceMappingURL=scanEntityFiles.cjs.map

package/build/scanEntityFiles.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanEntityFiles.cjs","names":["readFile","join"],"sources":["../src/scanEntityFiles.ts"],"sourcesContent":["import { readFile } from \"fs/promises\";\nimport { join } from \"path\";\n\nimport { type Config } from \"./config.ts\";\nimport {\n  type DbMetadata,\n  type EntityDbMetadata,\n  type EnumField,\n  type ManyToOneField,\n  type PgEnumField,\n  type PolymorphicField,\n  type PrimitiveField,\n} from \"./EntityDbMetadata.ts\";\n\n// Erg, we need a regex in case the fieldName arg is wrapped onto a new line... :-/\nconst regex = /config\\.setDefault\\([\\s\\n]*[\"'](\\w+)[\"']/g;\n\n/** Scans the entity files themselves for usage hints (like `setDefault` calls) to drive our codegen output. */\nexport async function scanEntityFiles(config: Config, dbMeta: DbMetadata): Promise<void> {\n  await Promise.all(\n    dbMeta.entities.map(async (entity) => {\n      try {\n        // load the entity.ts file (as a promise with fs/promises)\n        const tsCode = (await readFile(join(config.entitiesDirectory, `${entity.name}.ts`))).toString();\n        const defaultableFields = recursiveDefaultableFields(dbMeta, entity);\n        for (const match of tsCode.matchAll(regex)) {\n          const field = defaultableFields.find((f) => f.fieldName === match[1]);\n          if (field) {\n            field.hasConfigDefault = true;\n          }\n        }\n      } catch (e) {\n        // Ignore file not existing yet\n      }\n    }),\n  );\n}\n\n/**\n * Traverse the entity inheritance tree to find all fields that can have defaults set on them.\n *\n * I.e. a column defined in a base CTI table like `publishers.foo_bar` having a `config.setDefault` in\n * `SmallPublisher` and/or `LargePublisher`, or the same scenario for an STI table like `tasks.foo_bar`\n * with `TaskNew` and/or `TaskOld`.\n *\n * NOTE: I suspect here could be some edge cases here that will need to be ironed out, but should work\n * for simple inheritance structures. In particular, there may be unexpected side effects if a base\n * class field has a default set in one subtype, but not another.\n */\nfunction recursiveDefaultableFields(\n  dbMeta: DbMetadata,\n  entity: EntityDbMetadata | undefined,\n): Array<PrimitiveField | EnumField | PgEnumField | ManyToOneField | PolymorphicField> {\n  if (!entity) return [];\n  return [\n    ...entity.primitives,\n    ...entity.enums,\n    ...entity.pgEnums,\n    ...entity.manyToOnes,\n    ...entity.polymorphics,\n    ...(entity.baseClassName ? recursiveDefaultableFields(dbMeta, dbMeta.entitiesByName[entity.baseClassName]) : []),\n  ];\n}\n"],"mappings":";;;;;;AAeA,MAAM,QAAQ;;AAGd,eAAsB,gBAAgB,QAAgB,QAAmC;CACvF,MAAM,QAAQ,IACZ,OAAO,SAAS,IAAI,OAAO,WAAW;EACpC,IAAI;GAEF,MAAM,UAAU,OAAA,GAAMA,YAAAA,SAAAA,EAAAA,GAASC,KAAAA,KAAAA,CAAK,OAAO,mBAAmB,GAAG,OAAO,KAAK,IAAI,CAAC,EAAA,CAAG,SAAS;GAC9F,MAAM,oBAAoB,2BAA2B,QAAQ,MAAM;GACnE,KAAK,MAAM,SAAS,OAAO,SAAS,KAAK,GAAG;IAC1C,MAAM,QAAQ,kBAAkB,MAAM,MAAM,EAAE,cAAc,MAAM,EAAE;IACpE,IAAI,OACF,MAAM,mBAAmB;GAE7B;EACF,SAAS,GAAG,CAEZ;CACF,CAAC,CACH;AACF;;;;;;;;;;;;AAaA,SAAS,2BACP,QACA,QACqF;CACrF,IAAI,CAAC,QAAQ,OAAO,CAAC;CACrB,OAAO;EACL,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAI,OAAO,gBAAgB,2BAA2B,QAAQ,OAAO,eAAe,OAAO,cAAc,IAAI,CAAC;CAChH;AACF"}

package/build/scanEntityFiles.d.cts

@@ -0,0 +1,8 @@
+import { Config } from "./config.cjs";
+import { DbMetadata } from "./EntityDbMetadata.cjs";
+//#region src/scanEntityFiles.d.ts
+/** Scans the entity files themselves for usage hints (like `setDefault` calls) to drive our codegen output. */
+declare function scanEntityFiles(config: Config, dbMeta: DbMetadata): Promise<void>;
+//#endregion
+export { scanEntityFiles };
+//# sourceMappingURL=scanEntityFiles.d.cts.map

package/build/scanEntityFiles.d.cts.map

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

package/build/scanEntityFiles.d.mts

@@ -0,0 +1,8 @@
+import { Config } from "./config.mjs";
+import { DbMetadata } from "./EntityDbMetadata.mjs";
+//#region src/scanEntityFiles.d.ts
+/** Scans the entity files themselves for usage hints (like `setDefault` calls) to drive our codegen output. */
+declare function scanEntityFiles(config: Config, dbMeta: DbMetadata): Promise<void>;
+//#endregion
+export { scanEntityFiles };
+//# sourceMappingURL=scanEntityFiles.d.mts.map

package/build/scanEntityFiles.d.mts.map

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

package/build/scanEntityFiles.js

@@ -1,50 +1,45 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scanEntityFiles = scanEntityFiles;
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-// Erg, we need a regex in case the fieldName arg is wrapped onto a new line... :-/
+import "./config.js";
+import "./EntityDbMetadata.js";
+import { join } from "path";
+import { readFile } from "fs/promises";
+//#region src/scanEntityFiles.ts
 const regex = /config\.setDefault\([\s\n]*["'](\w+)["']/g;
 /** Scans the entity files themselves for usage hints (like `setDefault` calls) to drive our codegen output. */
 async function scanEntityFiles(config, dbMeta) {
-    await Promise.all(dbMeta.entities.map(async (entity) => {
-        try {
-            // load the entity.ts file (as a promise with fs/promises)
-            const tsCode = (await (0, promises_1.readFile)((0, path_1.join)(config.entitiesDirectory, `${entity.name}.ts`))).toString();
-            const defaultableFields = recursiveDefaultableFields(dbMeta, entity);
-            for (const match of tsCode.matchAll(regex)) {
-                const field = defaultableFields.find((f) => f.fieldName === match[1]);
-                if (field) {
-                    field.hasConfigDefault = true;
-                }
-            }
-        }
-        catch (e) {
-            // Ignore file not existing yet
-        }
-    }));
+	await Promise.all(dbMeta.entities.map(async (entity) => {
+		try {
+			const tsCode = (await readFile(join(config.entitiesDirectory, `${entity.name}.ts`))).toString();
+			const defaultableFields = recursiveDefaultableFields(dbMeta, entity);
+			for (const match of tsCode.matchAll(regex)) {
+				const field = defaultableFields.find((f) => f.fieldName === match[1]);
+				if (field) field.hasConfigDefault = true;
+			}
+		} catch (e) {}
+	}));
 }
 /**
- * Traverse the entity inheritance tree to find all fields that can have defaults set on them.
- *
- * I.e. a column defined in a base CTI table like `publishers.foo_bar` having a `config.setDefault` in
- * `SmallPublisher` and/or `LargePublisher`, or the same scenario for an STI table like `tasks.foo_bar`
- * with `TaskNew` and/or `TaskOld`.
- *
- * NOTE: I suspect here could be some edge cases here that will need to be ironed out, but should work
- * for simple inheritance structures. In particular, there may be unexpected side effects if a base
- * class field has a default set in one subtype, but not another.
- */
+* Traverse the entity inheritance tree to find all fields that can have defaults set on them.
+*
+* I.e. a column defined in a base CTI table like `publishers.foo_bar` having a `config.setDefault` in
+* `SmallPublisher` and/or `LargePublisher`, or the same scenario for an STI table like `tasks.foo_bar`
+* with `TaskNew` and/or `TaskOld`.
+*
+* NOTE: I suspect here could be some edge cases here that will need to be ironed out, but should work
+* for simple inheritance structures. In particular, there may be unexpected side effects if a base
+* class field has a default set in one subtype, but not another.
+*/
 function recursiveDefaultableFields(dbMeta, entity) {
-    if (!entity)
-        return [];
-    return [
-        ...entity.primitives,
-        ...entity.enums,
-        ...entity.pgEnums,
-        ...entity.manyToOnes,
-        ...entity.polymorphics,
-        ...(entity.baseClassName ? recursiveDefaultableFields(dbMeta, dbMeta.entitiesByName[entity.baseClassName]) : []),
-    ];
+	if (!entity) return [];
+	return [
+		...entity.primitives,
+		...entity.enums,
+		...entity.pgEnums,
+		...entity.manyToOnes,
+		...entity.polymorphics,
+		...entity.baseClassName ? recursiveDefaultableFields(dbMeta, dbMeta.entitiesByName[entity.baseClassName]) : []
+	];
 }
+//#endregion
+export { scanEntityFiles };
+
 //# sourceMappingURL=scanEntityFiles.js.map

package/build/scanEntityFiles.js.map

@@ -1 +1 @@
-{"version":3,"file":"scanEntityFiles.js","sourceRoot":"","sources":["../src/scanEntityFiles.ts"],"names":[],"mappings":";;AAiBA,0CAkBC;AAnCD,0CAAuC;AACvC,+BAA4B;AAY5B,mFAAmF;AACnF,MAAM,KAAK,GAAG,2CAA2C,CAAC;AAE1D,+GAA+G;AACxG,KAAK,UAAU,eAAe,CAAC,MAAc,EAAE,MAAkB;IACtE,MAAM,OAAO,CAAC,GAAG,CACf,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;QACnC,IAAI,CAAC;YACH,0DAA0D;YAC1D,MAAM,MAAM,GAAG,CAAC,MAAM,IAAA,mBAAQ,EAAC,IAAA,WAAI,EAAC,MAAM,CAAC,iBAAiB,EAAE,GAAG,MAAM,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;YAChG,MAAM,iBAAiB,GAAG,0BAA0B,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YACrE,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3C,MAAM,KAAK,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,SAAS,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;gBACtE,IAAI,KAAK,EAAE,CAAC;oBACV,KAAK,CAAC,gBAAgB,GAAG,IAAI,CAAC;gBAChC,CAAC;YACH,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,+BAA+B;QACjC,CAAC;IACH,CAAC,CAAC,CACH,CAAC;AACJ,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAS,0BAA0B,CACjC,MAAkB,EAClB,MAAoC;IAEpC,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IACvB,OAAO;QACL,GAAG,MAAM,CAAC,UAAU;QACpB,GAAG,MAAM,CAAC,KAAK;QACf,GAAG,MAAM,CAAC,OAAO;QACjB,GAAG,MAAM,CAAC,UAAU;QACpB,GAAG,MAAM,CAAC,YAAY;QACtB,GAAG,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,0BAA0B,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;KACjH,CAAC;AACJ,CAAC"}
+{"version":3,"file":"scanEntityFiles.js","names":[],"sources":["../src/scanEntityFiles.ts"],"sourcesContent":["import { readFile } from \"fs/promises\";\nimport { join } from \"path\";\n\nimport { type Config } from \"./config.ts\";\nimport {\n  type DbMetadata,\n  type EntityDbMetadata,\n  type EnumField,\n  type ManyToOneField,\n  type PgEnumField,\n  type PolymorphicField,\n  type PrimitiveField,\n} from \"./EntityDbMetadata.ts\";\n\n// Erg, we need a regex in case the fieldName arg is wrapped onto a new line... :-/\nconst regex = /config\\.setDefault\\([\\s\\n]*[\"'](\\w+)[\"']/g;\n\n/** Scans the entity files themselves for usage hints (like `setDefault` calls) to drive our codegen output. */\nexport async function scanEntityFiles(config: Config, dbMeta: DbMetadata): Promise<void> {\n  await Promise.all(\n    dbMeta.entities.map(async (entity) => {\n      try {\n        // load the entity.ts file (as a promise with fs/promises)\n        const tsCode = (await readFile(join(config.entitiesDirectory, `${entity.name}.ts`))).toString();\n        const defaultableFields = recursiveDefaultableFields(dbMeta, entity);\n        for (const match of tsCode.matchAll(regex)) {\n          const field = defaultableFields.find((f) => f.fieldName === match[1]);\n          if (field) {\n            field.hasConfigDefault = true;\n          }\n        }\n      } catch (e) {\n        // Ignore file not existing yet\n      }\n    }),\n  );\n}\n\n/**\n * Traverse the entity inheritance tree to find all fields that can have defaults set on them.\n *\n * I.e. a column defined in a base CTI table like `publishers.foo_bar` having a `config.setDefault` in\n * `SmallPublisher` and/or `LargePublisher`, or the same scenario for an STI table like `tasks.foo_bar`\n * with `TaskNew` and/or `TaskOld`.\n *\n * NOTE: I suspect here could be some edge cases here that will need to be ironed out, but should work\n * for simple inheritance structures. In particular, there may be unexpected side effects if a base\n * class field has a default set in one subtype, but not another.\n */\nfunction recursiveDefaultableFields(\n  dbMeta: DbMetadata,\n  entity: EntityDbMetadata | undefined,\n): Array<PrimitiveField | EnumField | PgEnumField | ManyToOneField | PolymorphicField> {\n  if (!entity) return [];\n  return [\n    ...entity.primitives,\n    ...entity.enums,\n    ...entity.pgEnums,\n    ...entity.manyToOnes,\n    ...entity.polymorphics,\n    ...(entity.baseClassName ? recursiveDefaultableFields(dbMeta, dbMeta.entitiesByName[entity.baseClassName]) : []),\n  ];\n}\n"],"mappings":";;;;;AAeA,MAAM,QAAQ;;AAGd,eAAsB,gBAAgB,QAAgB,QAAmC;CACvF,MAAM,QAAQ,IACZ,OAAO,SAAS,IAAI,OAAO,WAAW;EACpC,IAAI;GAEF,MAAM,UAAU,MAAM,SAAS,KAAK,OAAO,mBAAmB,GAAG,OAAO,KAAK,IAAI,CAAC,EAAA,CAAG,SAAS;GAC9F,MAAM,oBAAoB,2BAA2B,QAAQ,MAAM;GACnE,KAAK,MAAM,SAAS,OAAO,SAAS,KAAK,GAAG;IAC1C,MAAM,QAAQ,kBAAkB,MAAM,MAAM,EAAE,cAAc,MAAM,EAAE;IACpE,IAAI,OACF,MAAM,mBAAmB;GAE7B;EACF,SAAS,GAAG,CAEZ;CACF,CAAC,CACH;AACF;;;;;;;;;;;;AAaA,SAAS,2BACP,QACA,QACqF;CACrF,IAAI,CAAC,QAAQ,OAAO,CAAC;CACrB,OAAO;EACL,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAG,OAAO;EACV,GAAI,OAAO,gBAAgB,2BAA2B,QAAQ,OAAO,eAAe,OAAO,cAAc,IAAI,CAAC;CAChH;AACF"}

package/build/sortForeignKeys.cjs

@@ -0,0 +1,99 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./EntityDbMetadata.cjs");
+//#region src/sortForeignKeys.ts
+/**
+* Sorts entities by non-deferred foreign key order.
+*
+* Ideally databases/schemas will support/enable deferred FKs, which let us insert/delete rows
+* in any arbitrary order, and the FK checks will not be applied until txn commit.
+*
+* However, if not enabled/support, we have to worry about two things:
+*
+* 1. Inserting "parents" before their children
+*    - And if the parent has a circular reference to not-yet-inserted cycle
+* 2. Deleting "children" before their parents
+*    - Again if the parent has a circular reference to the child
+*
+* For both of these, we can just look at the FK ordering to "put the parent first",
+* but run into two problems:
+*
+* - If there is a cycle for not-null FKs, that breaks both INSERTs and DELETEs, so we
+* must warn the user about these to fix.
+* - If there is a cycle with nullable FKs, we can work around that by using NULL as a
+* transient/dummy value, for the initial insert, do the 2nd insert, and then "fixup" the
+* first insert with a UPDATE to the actual column value.
+*
+* Given ^, we set the `entity.nonDeferredFkOrder` of each entity, and then also return
+* two arrays of all soft-cycle (nullable, fixup-able) and hard-cycle (not-nullable, blocking)
+* keys.
+*/
+function sortByNonDeferredForeignKeys(entities) {
+	const graph = Object.fromEntries(entities.map((e) => [e.name, {
+		entity: e,
+		upstreamFks: /* @__PURE__ */ new Set(),
+		downstreamFks: /* @__PURE__ */ new Set()
+	}]));
+	const nullableCycles = [];
+	const notNullCycles = [];
+	entities.forEach((entity) => {
+		entity.nonDeferredFks.filter((m2o) => m2o.notNull).forEach((m2o) => {
+			const added = addDependency(graph, entity, m2o);
+			if (Array.isArray(added)) notNullCycles.push(added.join(" -> "));
+		});
+	});
+	entities.forEach((entity) => {
+		entity.nonDeferredFks.filter((m2o) => !m2o.notNull).forEach((m2o) => {
+			const added = addDependency(graph, entity, m2o);
+			if (Array.isArray(added)) nullableCycles.push(added.join(" -> "));
+		});
+	});
+	let queue = Object.values(graph).filter((n) => n.upstreamFks.size === 0);
+	let level = 1;
+	while (queue.length > 0) {
+		const nextLevel = [];
+		for (const current of queue) {
+			current.entity.nonDeferredFkOrder = level;
+			current.downstreamFks.forEach((node) => {
+				if (node.upstreamFks.delete(current) && node.upstreamFks.size === 0) nextLevel.push(node);
+			});
+		}
+		queue = nextLevel;
+		level++;
+	}
+	entities.filter((e) => e.nonDeferredFkOrder === -1).forEach((e) => e.nonDeferredFkOrder = 1e5);
+	return {
+		nullableCycles,
+		notNullCycles
+	};
+}
+function addDependency(graph, entity, m2o) {
+	const from = graph[entity.name];
+	const to = graph[m2o.otherEntity.name];
+	const cycle = willCreateCycle(graph, from, to);
+	if (cycle) return cycle;
+	from.upstreamFks.add(to);
+	to.downstreamFks.add(from);
+	return true;
+}
+function willCreateCycle(graph, from, to) {
+	return dfs(graph, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), [], from, to);
+}
+function dfs(graph, visited, stack, path, current, target) {
+	visited.add(current);
+	stack.add(current);
+	path.push(current);
+	for (const neighbor of current.downstreamFks) {
+		if (neighbor === target) return [...path, neighbor].map((n) => n.entity.name);
+		if (!visited.has(neighbor)) {
+			const cycle = dfs(graph, visited, stack, path, neighbor, target);
+			if (cycle) return cycle;
+		}
+	}
+	stack.delete(current);
+	path.pop();
+	return false;
+}
+//#endregion
+exports.sortByNonDeferredForeignKeys = sortByNonDeferredForeignKeys;
+
+//# sourceMappingURL=sortForeignKeys.cjs.map

package/build/sortForeignKeys.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortForeignKeys.cjs","names":[],"sources":["../src/sortForeignKeys.ts"],"sourcesContent":["import { type EntityDbMetadata, type ManyToOneField, type PolymorphicFieldComponent } from \"./EntityDbMetadata.ts\";\n\n/**\n * Sorts entities by non-deferred foreign key order.\n *\n * Ideally databases/schemas will support/enable deferred FKs, which let us insert/delete rows\n * in any arbitrary order, and the FK checks will not be applied until txn commit.\n *\n * However, if not enabled/support, we have to worry about two things:\n *\n * 1. Inserting \"parents\" before their children\n *    - And if the parent has a circular reference to not-yet-inserted cycle\n * 2. Deleting \"children\" before their parents\n *    - Again if the parent has a circular reference to the child\n *\n * For both of these, we can just look at the FK ordering to \"put the parent first\",\n * but run into two problems:\n *\n * - If there is a cycle for not-null FKs, that breaks both INSERTs and DELETEs, so we\n * must warn the user about these to fix.\n * - If there is a cycle with nullable FKs, we can work around that by using NULL as a\n * transient/dummy value, for the initial insert, do the 2nd insert, and then \"fixup\" the\n * first insert with a UPDATE to the actual column value.\n *\n * Given ^, we set the `entity.nonDeferredFkOrder` of each entity, and then also return\n * two arrays of all soft-cycle (nullable, fixup-able) and hard-cycle (not-nullable, blocking)\n * keys.\n */\nexport function sortByNonDeferredForeignKeys(entities: EntityDbMetadata[]): {\n  nullableCycles: string[];\n  notNullCycles: string[];\n} {\n  // Kahn's algorithm, O(V + E)\n\n  const graph: Record<string, Node> = Object.fromEntries(\n    entities.map((e) => [\n      e.name,\n      {\n        entity: e,\n        upstreamFks: new Set(),\n        downstreamFks: new Set(),\n      },\n    ]),\n  );\n\n  // Add all not-null deps first, as they are most important, cannot be fixed up.\n  // - Failures here are fatal-ish\n  // Then add nullable deps next, as they can be fixed-up\n\n  const nullableCycles: string[] = [];\n  const notNullCycles: string[] = [];\n\n  // If we see `books.author_id`, mark `author.inDegree++`\n  entities.forEach((entity) => {\n    entity.nonDeferredFks\n      .filter((m2o) => m2o.notNull)\n      .forEach((m2o) => {\n        const added = addDependency(graph, entity, m2o);\n        if (Array.isArray(added)) notNullCycles.push(added.join(\" -> \"));\n      });\n  });\n\n  // Do it again for nullable\n  entities.forEach((entity) => {\n    entity.nonDeferredFks\n      .filter((m2o) => !m2o.notNull)\n      .forEach((m2o) => {\n        const added = addDependency(graph, entity, m2o);\n        if (Array.isArray(added)) nullableCycles.push(added.join(\" -> \"));\n      });\n  });\n\n  // Topological Sort\n  // Enqueue entities with 0 out-degree (reverse Kahn), i.e. `authors`, they'll be at the top of the tree\n  let queue = Object.values(graph).filter((n) => n.upstreamFks.size === 0);\n  let level = 1;\n  while (queue.length > 0) {\n    // console.log(`Queue: ${queue.map((n) => n.entity.name)}`);\n    const nextLevel: Node[] = [];\n    for (const current of queue) {\n      current.entity.nonDeferredFkOrder = level;\n      current.downstreamFks.forEach((node) => {\n        if (node.upstreamFks.delete(current) && node.upstreamFks.size === 0) {\n          nextLevel.push(node);\n        }\n      });\n    }\n    queue = nextLevel;\n    level++;\n  }\n\n  // Anything left with a -1 value means there is a cycle\n  // Use a marker value for \"cyclic\"\n  entities.filter((e) => e.nonDeferredFkOrder === -1).forEach((e) => (e.nonDeferredFkOrder = 100_000));\n\n  return { nullableCycles, notNullCycles: notNullCycles };\n}\n\ntype Node = {\n  entity: EntityDbMetadata;\n  upstreamFks: Set<Node>;\n  downstreamFks: Set<Node>;\n};\n\nfunction addDependency(\n  graph: Record<string, Node>,\n  entity: EntityDbMetadata,\n  m2o: ManyToOneField | PolymorphicFieldComponent,\n): true | string[] {\n  const from = graph[entity.name]; // i.e. books\n  const to = graph[m2o.otherEntity.name]; // i.e. authors\n  const cycle = willCreateCycle(graph, from, to);\n  if (cycle) {\n    // console.log(`Skipped ${entity.name}.${m2o.columnName} -> ${m2o.otherEntity.name}`);\n    return cycle;\n  }\n  // console.log(`Added ${entity.name}.${m2o.columnName} -> ${m2o.otherEntity.name}`);\n  from.upstreamFks.add(to);\n  to.downstreamFks.add(from);\n  return true;\n}\n\nfunction willCreateCycle(graph: Record<string, Node>, from: Node, to: Node): false | string[] {\n  const visited: Set<Node> = new Set();\n  const stack: Set<Node> = new Set();\n  const path: Node[] = [];\n  // If `from=books[.author_id]` pointing at `to=authors`, we want to do `to.downstreamFks.add(from)`,\n  // but first make sure that none of from's dowstreams are to, because if so it would make a cycle.\n  return dfs(graph, visited, stack, path, from, to);\n}\n\nfunction dfs(\n  graph: Record<string, Node>,\n  visited: Set<Node>,\n  stack: Set<Node>,\n  path: Node[],\n  current: Node,\n  target: Node,\n): false | string[] {\n  visited.add(current);\n  stack.add(current);\n  path.push(current);\n  for (const neighbor of current.downstreamFks) {\n    if (neighbor === target) {\n      return [...path, neighbor].map((n) => n.entity.name);\n    }\n    if (!visited.has(neighbor)) {\n      const cycle = dfs(graph, visited, stack, path, neighbor, target);\n      if (cycle) return cycle;\n    }\n  }\n  stack.delete(current);\n  path.pop();\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,6BAA6B,UAG3C;CAGA,MAAM,QAA8B,OAAO,YACzC,SAAS,KAAK,MAAM,CAClB,EAAE,MACF;EACE,QAAQ;EACR,6BAAa,IAAI,IAAI;EACrB,+BAAe,IAAI,IAAI;CACzB,CACF,CAAC,CACH;CAMA,MAAM,iBAA2B,CAAC;CAClC,MAAM,gBAA0B,CAAC;CAGjC,SAAS,SAAS,WAAW;EAC3B,OAAO,eACJ,QAAQ,QAAQ,IAAI,OAAO,CAAC,CAC5B,SAAS,QAAQ;GAChB,MAAM,QAAQ,cAAc,OAAO,QAAQ,GAAG;GAC9C,IAAI,MAAM,QAAQ,KAAK,GAAG,cAAc,KAAK,MAAM,KAAK,MAAM,CAAC;EACjE,CAAC;CACL,CAAC;CAGD,SAAS,SAAS,WAAW;EAC3B,OAAO,eACJ,QAAQ,QAAQ,CAAC,IAAI,OAAO,CAAC,CAC7B,SAAS,QAAQ;GAChB,MAAM,QAAQ,cAAc,OAAO,QAAQ,GAAG;GAC9C,IAAI,MAAM,QAAQ,KAAK,GAAG,eAAe,KAAK,MAAM,KAAK,MAAM,CAAC;EAClE,CAAC;CACL,CAAC;CAID,IAAI,QAAQ,OAAO,OAAO,KAAK,CAAC,CAAC,QAAQ,MAAM,EAAE,YAAY,SAAS,CAAC;CACvE,IAAI,QAAQ;CACZ,OAAO,MAAM,SAAS,GAAG;EAEvB,MAAM,YAAoB,CAAC;EAC3B,KAAK,MAAM,WAAW,OAAO;GAC3B,QAAQ,OAAO,qBAAqB;GACpC,QAAQ,cAAc,SAAS,SAAS;IACtC,IAAI,KAAK,YAAY,OAAO,OAAO,KAAK,KAAK,YAAY,SAAS,GAChE,UAAU,KAAK,IAAI;GAEvB,CAAC;EACH;EACA,QAAQ;EACR;CACF;CAIA,SAAS,QAAQ,MAAM,EAAE,uBAAuB,EAAE,CAAC,CAAC,SAAS,MAAO,EAAE,qBAAqB,GAAQ;CAEnG,OAAO;EAAE;EAA+B;CAAc;AACxD;AAQA,SAAS,cACP,OACA,QACA,KACiB;CACjB,MAAM,OAAO,MAAM,OAAO;CAC1B,MAAM,KAAK,MAAM,IAAI,YAAY;CACjC,MAAM,QAAQ,gBAAgB,OAAO,MAAM,EAAE;CAC7C,IAAI,OAEF,OAAO;CAGT,KAAK,YAAY,IAAI,EAAE;CACvB,GAAG,cAAc,IAAI,IAAI;CACzB,OAAO;AACT;AAEA,SAAS,gBAAgB,OAA6B,MAAY,IAA4B;CAM5F,OAAO,IAAI,uBAAO,IALa,IAKP,mBAAG,IAJE,IAIE,GAAG,CAAG,GAAG,MAAM,EAAE;AAClD;AAEA,SAAS,IACP,OACA,SACA,OACA,MACA,SACA,QACkB;CAClB,QAAQ,IAAI,OAAO;CACnB,MAAM,IAAI,OAAO;CACjB,KAAK,KAAK,OAAO;CACjB,KAAK,MAAM,YAAY,QAAQ,eAAe;EAC5C,IAAI,aAAa,QACf,OAAO,CAAC,GAAG,MAAM,QAAQ,CAAC,CAAC,KAAK,MAAM,EAAE,OAAO,IAAI;EAErD,IAAI,CAAC,QAAQ,IAAI,QAAQ,GAAG;GAC1B,MAAM,QAAQ,IAAI,OAAO,SAAS,OAAO,MAAM,UAAU,MAAM;GAC/D,IAAI,OAAO,OAAO;EACpB;CACF;CACA,MAAM,OAAO,OAAO;CACpB,KAAK,IAAI;CACT,OAAO;AACT"}

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

@@ -1,4 +1,5 @@
-import { EntityDbMetadata } from "./EntityDbMetadata";
+import { EntityDbMetadata } from "./EntityDbMetadata.cjs";
+//#region src/sortForeignKeys.d.ts
 /**
  * Sorts entities by non-deferred foreign key order.
  *
@@ -25,8 +26,10 @@ import { EntityDbMetadata } from "./EntityDbMetadata";
  * two arrays of all soft-cycle (nullable, fixup-able) and hard-cycle (not-nullable, blocking)
  * keys.
  */
-export declare function sortByNonDeferredForeignKeys(entities: EntityDbMetadata[]): {
-    nullableCycles: string[];
-    notNullCycles: string[];
+declare function sortByNonDeferredForeignKeys(entities: EntityDbMetadata[]): {
+  nullableCycles: string[];
+  notNullCycles: string[];
 };
-//# sourceMappingURL=sortForeignKeys.d.ts.map
+//#endregion
+export { sortByNonDeferredForeignKeys };
+//# sourceMappingURL=sortForeignKeys.d.cts.map

package/build/sortForeignKeys.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortForeignKeys.d.cts","names":[],"sources":["../src/sortForeignKeys.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BgB,6BAA6B,UAAU;EACrD;EACA"}

package/build/sortForeignKeys.d.mts

@@ -0,0 +1,35 @@
+import { EntityDbMetadata } from "./EntityDbMetadata.mjs";
+//#region src/sortForeignKeys.d.ts
+/**
+ * Sorts entities by non-deferred foreign key order.
+ *
+ * Ideally databases/schemas will support/enable deferred FKs, which let us insert/delete rows
+ * in any arbitrary order, and the FK checks will not be applied until txn commit.
+ *
+ * However, if not enabled/support, we have to worry about two things:
+ *
+ * 1. Inserting "parents" before their children
+ *    - And if the parent has a circular reference to not-yet-inserted cycle
+ * 2. Deleting "children" before their parents
+ *    - Again if the parent has a circular reference to the child
+ *
+ * For both of these, we can just look at the FK ordering to "put the parent first",
+ * but run into two problems:
+ *
+ * - If there is a cycle for not-null FKs, that breaks both INSERTs and DELETEs, so we
+ * must warn the user about these to fix.
+ * - If there is a cycle with nullable FKs, we can work around that by using NULL as a
+ * transient/dummy value, for the initial insert, do the 2nd insert, and then "fixup" the
+ * first insert with a UPDATE to the actual column value.
+ *
+ * Given ^, we set the `entity.nonDeferredFkOrder` of each entity, and then also return
+ * two arrays of all soft-cycle (nullable, fixup-able) and hard-cycle (not-nullable, blocking)
+ * keys.
+ */
+declare function sortByNonDeferredForeignKeys(entities: EntityDbMetadata[]): {
+  nullableCycles: string[];
+  notNullCycles: string[];
+};
+//#endregion
+export { sortByNonDeferredForeignKeys };
+//# sourceMappingURL=sortForeignKeys.d.mts.map

package/build/sortForeignKeys.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortForeignKeys.d.mts","names":[],"sources":["../src/sortForeignKeys.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BgB,6BAA6B,UAAU;EACrD;EACA"}

package/build/sortForeignKeys.js

@@ -1,127 +1,98 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortByNonDeferredForeignKeys = sortByNonDeferredForeignKeys;
+import "./EntityDbMetadata.js";
+//#region src/sortForeignKeys.ts
 /**
- * Sorts entities by non-deferred foreign key order.
- *
- * Ideally databases/schemas will support/enable deferred FKs, which let us insert/delete rows
- * in any arbitrary order, and the FK checks will not be applied until txn commit.
- *
- * However, if not enabled/support, we have to worry about two things:
- *
- * 1. Inserting "parents" before their children
- *    - And if the parent has a circular reference to not-yet-inserted cycle
- * 2. Deleting "children" before their parents
- *    - Again if the parent has a circular reference to the child
- *
- * For both of these, we can just look at the FK ordering to "put the parent first",
- * but run into two problems:
- *
- * - If there is a cycle for not-null FKs, that breaks both INSERTs and DELETEs, so we
- * must warn the user about these to fix.
- * - If there is a cycle with nullable FKs, we can work around that by using NULL as a
- * transient/dummy value, for the initial insert, do the 2nd insert, and then "fixup" the
- * first insert with a UPDATE to the actual column value.
- *
- * Given ^, we set the `entity.nonDeferredFkOrder` of each entity, and then also return
- * two arrays of all soft-cycle (nullable, fixup-able) and hard-cycle (not-nullable, blocking)
- * keys.
- */
+* Sorts entities by non-deferred foreign key order.
+*
+* Ideally databases/schemas will support/enable deferred FKs, which let us insert/delete rows
+* in any arbitrary order, and the FK checks will not be applied until txn commit.
+*
+* However, if not enabled/support, we have to worry about two things:
+*
+* 1. Inserting "parents" before their children
+*    - And if the parent has a circular reference to not-yet-inserted cycle
+* 2. Deleting "children" before their parents
+*    - Again if the parent has a circular reference to the child
+*
+* For both of these, we can just look at the FK ordering to "put the parent first",
+* but run into two problems:
+*
+* - If there is a cycle for not-null FKs, that breaks both INSERTs and DELETEs, so we
+* must warn the user about these to fix.
+* - If there is a cycle with nullable FKs, we can work around that by using NULL as a
+* transient/dummy value, for the initial insert, do the 2nd insert, and then "fixup" the
+* first insert with a UPDATE to the actual column value.
+*
+* Given ^, we set the `entity.nonDeferredFkOrder` of each entity, and then also return
+* two arrays of all soft-cycle (nullable, fixup-able) and hard-cycle (not-nullable, blocking)
+* keys.
+*/
 function sortByNonDeferredForeignKeys(entities) {
-    // Kahn's algorithm, O(V + E)
-    const graph = Object.fromEntries(entities.map((e) => [
-        e.name,
-        {
-            entity: e,
-            upstreamFks: new Set(),
-            downstreamFks: new Set(),
-        },
-    ]));
-    // Add all not-null deps first, as they are most important, cannot be fixed up.
-    // - Failures here are fatal-ish
-    // Then add nullable deps next, as they can be fixed-up
-    const nullableCycles = [];
-    const notNullCycles = [];
-    // If we see `books.author_id`, mark `author.inDegree++`
-    entities.forEach((entity) => {
-        entity.nonDeferredFks
-            .filter((m2o) => m2o.notNull)
-            .forEach((m2o) => {
-            const added = addDependency(graph, entity, m2o);
-            if (Array.isArray(added))
-                notNullCycles.push(added.join(" -> "));
-        });
-    });
-    // Do it again for nullable
-    entities.forEach((entity) => {
-        entity.nonDeferredFks
-            .filter((m2o) => !m2o.notNull)
-            .forEach((m2o) => {
-            const added = addDependency(graph, entity, m2o);
-            if (Array.isArray(added))
-                nullableCycles.push(added.join(" -> "));
-        });
-    });
-    // Topological Sort
-    // Enqueue entities with 0 out-degree (reverse Kahn), i.e. `authors`, they'll be at the top of the tree
-    let queue = Object.values(graph).filter((n) => n.upstreamFks.size === 0);
-    let level = 1;
-    while (queue.length > 0) {
-        // console.log(`Queue: ${queue.map((n) => n.entity.name)}`);
-        const nextLevel = [];
-        for (const current of queue) {
-            current.entity.nonDeferredFkOrder = level;
-            current.downstreamFks.forEach((node) => {
-                if (node.upstreamFks.delete(current) && node.upstreamFks.size === 0) {
-                    nextLevel.push(node);
-                }
-            });
-        }
-        queue = nextLevel;
-        level++;
-    }
-    // Anything left with a -1 value means there is a cycle
-    // Use a marker value for "cyclic"
-    entities.filter((e) => e.nonDeferredFkOrder === -1).forEach((e) => (e.nonDeferredFkOrder = 100_000));
-    return { nullableCycles, notNullCycles: notNullCycles };
+	const graph = Object.fromEntries(entities.map((e) => [e.name, {
+		entity: e,
+		upstreamFks: /* @__PURE__ */ new Set(),
+		downstreamFks: /* @__PURE__ */ new Set()
+	}]));
+	const nullableCycles = [];
+	const notNullCycles = [];
+	entities.forEach((entity) => {
+		entity.nonDeferredFks.filter((m2o) => m2o.notNull).forEach((m2o) => {
+			const added = addDependency(graph, entity, m2o);
+			if (Array.isArray(added)) notNullCycles.push(added.join(" -> "));
+		});
+	});
+	entities.forEach((entity) => {
+		entity.nonDeferredFks.filter((m2o) => !m2o.notNull).forEach((m2o) => {
+			const added = addDependency(graph, entity, m2o);
+			if (Array.isArray(added)) nullableCycles.push(added.join(" -> "));
+		});
+	});
+	let queue = Object.values(graph).filter((n) => n.upstreamFks.size === 0);
+	let level = 1;
+	while (queue.length > 0) {
+		const nextLevel = [];
+		for (const current of queue) {
+			current.entity.nonDeferredFkOrder = level;
+			current.downstreamFks.forEach((node) => {
+				if (node.upstreamFks.delete(current) && node.upstreamFks.size === 0) nextLevel.push(node);
+			});
+		}
+		queue = nextLevel;
+		level++;
+	}
+	entities.filter((e) => e.nonDeferredFkOrder === -1).forEach((e) => e.nonDeferredFkOrder = 1e5);
+	return {
+		nullableCycles,
+		notNullCycles
+	};
 }
 function addDependency(graph, entity, m2o) {
-    const from = graph[entity.name]; // i.e. books
-    const to = graph[m2o.otherEntity.name]; // i.e. authors
-    const cycle = willCreateCycle(graph, from, to);
-    if (cycle) {
-        // console.log(`Skipped ${entity.name}.${m2o.columnName} -> ${m2o.otherEntity.name}`);
-        return cycle;
-    }
-    // console.log(`Added ${entity.name}.${m2o.columnName} -> ${m2o.otherEntity.name}`);
-    from.upstreamFks.add(to);
-    to.downstreamFks.add(from);
-    return true;
+	const from = graph[entity.name];
+	const to = graph[m2o.otherEntity.name];
+	const cycle = willCreateCycle(graph, from, to);
+	if (cycle) return cycle;
+	from.upstreamFks.add(to);
+	to.downstreamFks.add(from);
+	return true;
 }
 function willCreateCycle(graph, from, to) {
-    const visited = new Set();
-    const stack = new Set();
-    const path = [];
-    // If `from=books[.author_id]` pointing at `to=authors`, we want to do `to.downstreamFks.add(from)`,
-    // but first make sure that none of from's dowstreams are to, because if so it would make a cycle.
-    return dfs(graph, visited, stack, path, from, to);
+	return dfs(graph, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), [], from, to);
 }
 function dfs(graph, visited, stack, path, current, target) {
-    visited.add(current);
-    stack.add(current);
-    path.push(current);
-    for (const neighbor of current.downstreamFks) {
-        if (neighbor === target) {
-            return [...path, neighbor].map((n) => n.entity.name);
-        }
-        if (!visited.has(neighbor)) {
-            const cycle = dfs(graph, visited, stack, path, neighbor, target);
-            if (cycle)
-                return cycle;
-        }
-    }
-    stack.delete(current);
-    path.pop();
-    return false;
+	visited.add(current);
+	stack.add(current);
+	path.push(current);
+	for (const neighbor of current.downstreamFks) {
+		if (neighbor === target) return [...path, neighbor].map((n) => n.entity.name);
+		if (!visited.has(neighbor)) {
+			const cycle = dfs(graph, visited, stack, path, neighbor, target);
+			if (cycle) return cycle;
+		}
+	}
+	stack.delete(current);
+	path.pop();
+	return false;
 }
+//#endregion
+export { sortByNonDeferredForeignKeys };
+
 //# sourceMappingURL=sortForeignKeys.js.map

package/build/sortForeignKeys.js.map

@@ -1 +1 @@
-{"version":3,"file":"sortForeignKeys.js","sourceRoot":"","sources":["../src/sortForeignKeys.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sortForeignKeys.js","names":[],"sources":["../src/sortForeignKeys.ts"],"sourcesContent":["import { type EntityDbMetadata, type ManyToOneField, type PolymorphicFieldComponent } from \"./EntityDbMetadata.ts\";\n\n/**\n * Sorts entities by non-deferred foreign key order.\n *\n * Ideally databases/schemas will support/enable deferred FKs, which let us insert/delete rows\n * in any arbitrary order, and the FK checks will not be applied until txn commit.\n *\n * However, if not enabled/support, we have to worry about two things:\n *\n * 1. Inserting \"parents\" before their children\n *    - And if the parent has a circular reference to not-yet-inserted cycle\n * 2. Deleting \"children\" before their parents\n *    - Again if the parent has a circular reference to the child\n *\n * For both of these, we can just look at the FK ordering to \"put the parent first\",\n * but run into two problems:\n *\n * - If there is a cycle for not-null FKs, that breaks both INSERTs and DELETEs, so we\n * must warn the user about these to fix.\n * - If there is a cycle with nullable FKs, we can work around that by using NULL as a\n * transient/dummy value, for the initial insert, do the 2nd insert, and then \"fixup\" the\n * first insert with a UPDATE to the actual column value.\n *\n * Given ^, we set the `entity.nonDeferredFkOrder` of each entity, and then also return\n * two arrays of all soft-cycle (nullable, fixup-able) and hard-cycle (not-nullable, blocking)\n * keys.\n */\nexport function sortByNonDeferredForeignKeys(entities: EntityDbMetadata[]): {\n  nullableCycles: string[];\n  notNullCycles: string[];\n} {\n  // Kahn's algorithm, O(V + E)\n\n  const graph: Record<string, Node> = Object.fromEntries(\n    entities.map((e) => [\n      e.name,\n      {\n        entity: e,\n        upstreamFks: new Set(),\n        downstreamFks: new Set(),\n      },\n    ]),\n  );\n\n  // Add all not-null deps first, as they are most important, cannot be fixed up.\n  // - Failures here are fatal-ish\n  // Then add nullable deps next, as they can be fixed-up\n\n  const nullableCycles: string[] = [];\n  const notNullCycles: string[] = [];\n\n  // If we see `books.author_id`, mark `author.inDegree++`\n  entities.forEach((entity) => {\n    entity.nonDeferredFks\n      .filter((m2o) => m2o.notNull)\n      .forEach((m2o) => {\n        const added = addDependency(graph, entity, m2o);\n        if (Array.isArray(added)) notNullCycles.push(added.join(\" -> \"));\n      });\n  });\n\n  // Do it again for nullable\n  entities.forEach((entity) => {\n    entity.nonDeferredFks\n      .filter((m2o) => !m2o.notNull)\n      .forEach((m2o) => {\n        const added = addDependency(graph, entity, m2o);\n        if (Array.isArray(added)) nullableCycles.push(added.join(\" -> \"));\n      });\n  });\n\n  // Topological Sort\n  // Enqueue entities with 0 out-degree (reverse Kahn), i.e. `authors`, they'll be at the top of the tree\n  let queue = Object.values(graph).filter((n) => n.upstreamFks.size === 0);\n  let level = 1;\n  while (queue.length > 0) {\n    // console.log(`Queue: ${queue.map((n) => n.entity.name)}`);\n    const nextLevel: Node[] = [];\n    for (const current of queue) {\n      current.entity.nonDeferredFkOrder = level;\n      current.downstreamFks.forEach((node) => {\n        if (node.upstreamFks.delete(current) && node.upstreamFks.size === 0) {\n          nextLevel.push(node);\n        }\n      });\n    }\n    queue = nextLevel;\n    level++;\n  }\n\n  // Anything left with a -1 value means there is a cycle\n  // Use a marker value for \"cyclic\"\n  entities.filter((e) => e.nonDeferredFkOrder === -1).forEach((e) => (e.nonDeferredFkOrder = 100_000));\n\n  return { nullableCycles, notNullCycles: notNullCycles };\n}\n\ntype Node = {\n  entity: EntityDbMetadata;\n  upstreamFks: Set<Node>;\n  downstreamFks: Set<Node>;\n};\n\nfunction addDependency(\n  graph: Record<string, Node>,\n  entity: EntityDbMetadata,\n  m2o: ManyToOneField | PolymorphicFieldComponent,\n): true | string[] {\n  const from = graph[entity.name]; // i.e. books\n  const to = graph[m2o.otherEntity.name]; // i.e. authors\n  const cycle = willCreateCycle(graph, from, to);\n  if (cycle) {\n    // console.log(`Skipped ${entity.name}.${m2o.columnName} -> ${m2o.otherEntity.name}`);\n    return cycle;\n  }\n  // console.log(`Added ${entity.name}.${m2o.columnName} -> ${m2o.otherEntity.name}`);\n  from.upstreamFks.add(to);\n  to.downstreamFks.add(from);\n  return true;\n}\n\nfunction willCreateCycle(graph: Record<string, Node>, from: Node, to: Node): false | string[] {\n  const visited: Set<Node> = new Set();\n  const stack: Set<Node> = new Set();\n  const path: Node[] = [];\n  // If `from=books[.author_id]` pointing at `to=authors`, we want to do `to.downstreamFks.add(from)`,\n  // but first make sure that none of from's dowstreams are to, because if so it would make a cycle.\n  return dfs(graph, visited, stack, path, from, to);\n}\n\nfunction dfs(\n  graph: Record<string, Node>,\n  visited: Set<Node>,\n  stack: Set<Node>,\n  path: Node[],\n  current: Node,\n  target: Node,\n): false | string[] {\n  visited.add(current);\n  stack.add(current);\n  path.push(current);\n  for (const neighbor of current.downstreamFks) {\n    if (neighbor === target) {\n      return [...path, neighbor].map((n) => n.entity.name);\n    }\n    if (!visited.has(neighbor)) {\n      const cycle = dfs(graph, visited, stack, path, neighbor, target);\n      if (cycle) return cycle;\n    }\n  }\n  stack.delete(current);\n  path.pop();\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,6BAA6B,UAG3C;CAGA,MAAM,QAA8B,OAAO,YACzC,SAAS,KAAK,MAAM,CAClB,EAAE,MACF;EACE,QAAQ;EACR,6BAAa,IAAI,IAAI;EACrB,+BAAe,IAAI,IAAI;CACzB,CACF,CAAC,CACH;CAMA,MAAM,iBAA2B,CAAC;CAClC,MAAM,gBAA0B,CAAC;CAGjC,SAAS,SAAS,WAAW;EAC3B,OAAO,eACJ,QAAQ,QAAQ,IAAI,OAAO,CAAC,CAC5B,SAAS,QAAQ;GAChB,MAAM,QAAQ,cAAc,OAAO,QAAQ,GAAG;GAC9C,IAAI,MAAM,QAAQ,KAAK,GAAG,cAAc,KAAK,MAAM,KAAK,MAAM,CAAC;EACjE,CAAC;CACL,CAAC;CAGD,SAAS,SAAS,WAAW;EAC3B,OAAO,eACJ,QAAQ,QAAQ,CAAC,IAAI,OAAO,CAAC,CAC7B,SAAS,QAAQ;GAChB,MAAM,QAAQ,cAAc,OAAO,QAAQ,GAAG;GAC9C,IAAI,MAAM,QAAQ,KAAK,GAAG,eAAe,KAAK,MAAM,KAAK,MAAM,CAAC;EAClE,CAAC;CACL,CAAC;CAID,IAAI,QAAQ,OAAO,OAAO,KAAK,CAAC,CAAC,QAAQ,MAAM,EAAE,YAAY,SAAS,CAAC;CACvE,IAAI,QAAQ;CACZ,OAAO,MAAM,SAAS,GAAG;EAEvB,MAAM,YAAoB,CAAC;EAC3B,KAAK,MAAM,WAAW,OAAO;GAC3B,QAAQ,OAAO,qBAAqB;GACpC,QAAQ,cAAc,SAAS,SAAS;IACtC,IAAI,KAAK,YAAY,OAAO,OAAO,KAAK,KAAK,YAAY,SAAS,GAChE,UAAU,KAAK,IAAI;GAEvB,CAAC;EACH;EACA,QAAQ;EACR;CACF;CAIA,SAAS,QAAQ,MAAM,EAAE,uBAAuB,EAAE,CAAC,CAAC,SAAS,MAAO,EAAE,qBAAqB,GAAQ;CAEnG,OAAO;EAAE;EAA+B;CAAc;AACxD;AAQA,SAAS,cACP,OACA,QACA,KACiB;CACjB,MAAM,OAAO,MAAM,OAAO;CAC1B,MAAM,KAAK,MAAM,IAAI,YAAY;CACjC,MAAM,QAAQ,gBAAgB,OAAO,MAAM,EAAE;CAC7C,IAAI,OAEF,OAAO;CAGT,KAAK,YAAY,IAAI,EAAE;CACvB,GAAG,cAAc,IAAI,IAAI;CACzB,OAAO;AACT;AAEA,SAAS,gBAAgB,OAA6B,MAAY,IAA4B;CAM5F,OAAO,IAAI,uBAAO,IALa,IAKP,mBAAG,IAJE,IAIE,GAAG,CAAG,GAAG,MAAM,EAAE;AAClD;AAEA,SAAS,IACP,OACA,SACA,OACA,MACA,SACA,QACkB;CAClB,QAAQ,IAAI,OAAO;CACnB,MAAM,IAAI,OAAO;CACjB,KAAK,KAAK,OAAO;CACjB,KAAK,MAAM,YAAY,QAAQ,eAAe;EAC5C,IAAI,aAAa,QACf,OAAO,CAAC,GAAG,MAAM,QAAQ,CAAC,CAAC,KAAK,MAAM,EAAE,OAAO,IAAI;EAErD,IAAI,CAAC,QAAQ,IAAI,QAAQ,GAAG;GAC1B,MAAM,QAAQ,IAAI,OAAO,SAAS,OAAO,MAAM,UAAU,MAAM;GAC/D,IAAI,OAAO,OAAO;EACpB;CACF;CACA,MAAM,OAAO,OAAO;CACpB,KAAK,IAAI;CACT,OAAO;AACT"}