joist-codegen 2.3.0 → 2.4.0

package/build/EntityDbMetadata.js

@@ -1,773 +1,661 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityDbMetadata = void 0;
-exports.oneToOneName = oneToOneName;
-exports.referenceName = referenceName;
-exports.manyToManyName = manyToManyName;
-exports.collectionName = collectionName;
-exports.failIfOverlappingFieldNames = failIfOverlappingFieldNames;
-exports.makeEntity = makeEntity;
-exports.canonicalizeOtherEntities = canonicalizeOtherEntities;
-exports.resolveNameConflicts = resolveNameConflicts;
-const change_case_1 = require("change-case");
-const joist_utils_1 = require("joist-utils");
-const pg_structure_1 = require("pg-structure");
-const pluralize_1 = require("pluralize");
-const ts_poet_1 = require("ts-poet");
-const config_1 = require("./config");
-const symbols_1 = require("./symbols");
-const utils_1 = require("./utils");
-/** Adapts the generally-great pg-structure metadata into our specific ORM types. */
-class EntityDbMetadata {
-    entity;
-    primaryKey;
-    primitives;
-    enums;
-    pgEnums;
-    manyToOnes;
-    oneToManys;
-    largeOneToManys;
-    oneToOnes;
-    manyToManys;
-    largeManyToManys;
-    manyToManyEnums;
-    polymorphics;
-    tableName;
-    tagName;
-    createdAt;
-    updatedAt;
-    deletedAt;
-    baseClassName;
-    baseType;
-    subTypes = [];
-    inheritanceType;
-    /** This will only be set on the base meta. */
-    stiDiscriminatorField;
-    /** This will only be set on the sub metas. */
-    stiDiscriminatorValue;
-    abstract;
-    nonDeferredFkOrder = -1;
-    uniqueConstraints;
-    constructor(config, table, enums = {}) {
-        this.entity = makeEntity((0, utils_1.tableToEntityName)(config, table));
-        if ((0, utils_1.isSubClassTable)(table)) {
-            this.baseClassName = (0, utils_1.tableToEntityName)(config, table.columns.get("id").foreignKeys[0].referencedTable);
-            this.inheritanceType = "cti";
-        }
-        this.primaryKey =
-            table.columns
-                .filter((c) => c.isPrimaryKey)
-                .map((column) => newPrimitive(config, this.entity, column, table))[0] ||
-                (0, utils_1.fail)(`No primary key found for ${table.name}`);
-        this.primitives = table.columns
-            .filter((c) => !c.isPrimaryKey && !c.isForeignKey)
-            .filter((c) => !isEnumArray(c) && !isPgEnum(c))
-            .map((column) => newPrimitive(config, this.entity, column, table))
-            .filter((f) => !f.ignore);
-        this.enums = [
-            ...table.m2oRelations
-                .filter((r) => (0, utils_1.isEnumTable)(config, r.targetTable))
-                .map((r) => newEnumField(config, this.entity, r, enums))
-                .filter((f) => !f.ignore),
-            ...table.columns
-                .filter((c) => isEnumArray(c))
-                .map((column) => newEnumArrayField(config, this.entity, column, enums))
-                .filter((f) => !f.ignore),
-        ];
-        this.pgEnums = [
-            ...table.columns
-                .filter((c) => isPgEnum(c))
-                .map((column) => newPgEnumField(config, this.entity, column))
-                .filter((f) => !f.ignore),
-        ];
-        this.manyToOnes = table.m2oRelations
-            .filter((r) => !(0, utils_1.isEnumTable)(config, r.targetTable))
-            .filter((r) => !isMultiColumnForeignKey(r))
-            .filter((r) => !isComponentOfPolymorphicRelation(config, r))
-            .filter((r) => !isBaseClassForeignKey(r))
-            .map((r) => newManyToOneField(config, this.entity, r))
-            .filter((f) => !f.ignore);
-        // We split these into regular/large...
-        const allOneToManys = table.o2mRelations
-            // ManyToMany join tables also show up as OneToMany tables in pg-structure
-            .filter((r) => !(0, utils_1.isJoinTable)(config, r.targetTable))
-            .filter((r) => !isMultiColumnForeignKey(r))
-            .filter((r) => !isOneToOneRelation(r))
-            .map((r) => newOneToMany(config, this.entity, r))
-            // Do not generate o2m for ReactiveReferences
-            .filter((f) => !(0, config_1.isReactiveReference)(config, f.otherEntity, f.otherFieldName))
-            .filter((f) => !f.ignore);
-        this.oneToManys = allOneToManys.filter((f) => !f.isLargeCollection);
-        this.largeOneToManys = allOneToManys.filter((f) => f.isLargeCollection);
-        this.oneToOnes = table.o2mRelations
-            // ManyToMany join tables also show up as OneToMany tables in pg-structure
-            .filter((r) => !(0, utils_1.isJoinTable)(config, r.targetTable))
-            .filter((r) => !isMultiColumnForeignKey(r))
-            .filter((r) => !isBaseClassForeignKey(r))
-            .filter((r) => isOneToOneRelation(r))
-            .map((r) => newOneToOne(config, this.entity, r))
-            .filter((f) => !f.ignore);
-        // We split these into regular/large
-        const allManyToManys = table.m2mRelations
-            // pg-structure is really loose on what it considers a m2m relationship, i.e. any entity
-            // that has a foreign key to us, and a foreign key to something else, is automatically
-            // considered as a join table/m2m between "us" and "something else". Filter these out
-            // by looking for only true join tables, i.e. tables with only id, fk1, and fk2.
-            .filter((r) => (0, utils_1.isJoinTable)(config, r.joinTable))
-            .filter((r) => !isMultiColumnForeignKey(r))
-            // Join tables whose "other" side is an enum table become EnumCollections instead.
-            .filter((r) => !(0, utils_1.isEnumTable)(config, r.targetTable))
-            .map((r) => newManyToManyField(config, this.entity, r))
-            .filter((f) => !f.ignore);
-        this.manyToManys = allManyToManys.filter((f) => !f.isLargeCollection);
-        this.largeManyToManys = allManyToManys.filter((f) => f.isLargeCollection);
-        // A join table between us and an enum table, i.e. `Publisher.logoColors`.
-        this.manyToManyEnums = table.m2mRelations
-            .filter((r) => (0, utils_1.isJoinTable)(config, r.joinTable))
-            .filter((r) => !isMultiColumnForeignKey(r))
-            .filter((r) => (0, utils_1.isEnumTable)(config, r.targetTable))
-            .map((r) => newManyToManyEnumField(config, this.entity, r, enums))
-            .filter((f) => !f.ignore);
-        this.polymorphics = polymorphicRelations(config, table).map((rc) => newPolymorphicField(config, table, this.entity, rc));
-        this.tableName = table.name;
-        this.tagName = config.entities[this.entity.name]?.tag;
-        this.abstract = config.entities[this.entity.name]?.abstract || false;
-        const { createdAtConf, updatedAtConf, deletedAtConf } = (0, config_1.getTimestampConfig)(config);
-        this.createdAt = this.primitives.find((f) => createdAtConf.names.includes(f.columnName));
-        this.updatedAt = this.primitives.find((f) => updatedAtConf.names.includes(f.columnName));
-        this.deletedAt = this.primitives.find((f) => deletedAtConf.names.includes(f.columnName));
-        this.uniqueConstraints = inferUniqueConstraints(this, table);
-    }
-    get name() {
-        return this.entity.name;
-    }
-    get nonDeferredFks() {
-        return [
-            ...this.manyToOnes.filter((r) => !r.isDeferredAndDeferrable),
-            ...this.polymorphics.flatMap((p) => p.components).filter((c) => !c.isDeferredAndDeferrable),
-        ];
-    }
-    get nonDeferredManyToManyFks() {
-        return this.manyToManys.filter((r) => !r.isDeferredAndDeferrable);
-    }
-}
-exports.EntityDbMetadata = EntityDbMetadata;
+import { EnumType, M2ORelation } from "./pgMetadata.js";
+import { fail, isEnumTable, isJoinTable, isSubClassTable, joinTableHasId, mapSimpleDbTypeToTypescriptType, parseOrder, tableToEntityName } from "./utils.js";
+import { fieldTypeConfig, getTimestampConfig, isFieldHasDefault, isFieldIgnored, isGetterField, isLargeCollection, isLazyField, isProtected, isReactiveField, isReactiveManyToMany, isReactiveReference, ormMaintainedFields, serdeConfig, softDeletesConfig, superstructConfig, zodSchemaConfig } from "./config.js";
+import { Zod } from "./symbols.js";
+import "./loadMetadata.js";
+import { camelCase, pascalCase, snakeCase } from "change-case";
+import { groupBy } from "joist-utils";
+import pluralize from "pluralize";
+import { Import, code, imp } from "ts-poet";
+//#region src/EntityDbMetadata.ts
+const { plural, singular } = pluralize;
+/** Adapts PostgreSQL catalog metadata into our specific ORM types. */
+var EntityDbMetadata = class {
+	entity;
+	primaryKey;
+	primitives;
+	enums;
+	pgEnums;
+	manyToOnes;
+	oneToManys;
+	largeOneToManys;
+	oneToOnes;
+	manyToManys;
+	largeManyToManys;
+	manyToManyEnums;
+	polymorphics;
+	tableName;
+	tagName;
+	createdAt;
+	updatedAt;
+	deletedAt;
+	baseClassName;
+	baseType;
+	subTypes = [];
+	inheritanceType;
+	/** This will only be set on the base meta. */
+	stiDiscriminatorField;
+	/** This will only be set on the sub metas. */
+	stiDiscriminatorValue;
+	abstract;
+	nonDeferredFkOrder = -1;
+	uniqueConstraints;
+	/** Gates mutation targets, not reads; false when required columns or array storage have no supported mutation mapping. */
+	supportsEmExecute;
+	/** Original table fields, captured before inheritance partitions or specializes them. */
+	physicalMetadata;
+	/** Physical columns ignored by entity fields, retained for direct SQL reads and writes. */
+	ignoredColumns;
+	constructor(config, table, enums = {}) {
+		this.entity = makeEntity(tableToEntityName(config, table));
+		if (isSubClassTable(table)) {
+			this.baseClassName = tableToEntityName(config, table.columns.get("id").foreignKeys[0].referencedTable);
+			this.inheritanceType = "cti";
+		}
+		this.primaryKey = table.columns.filter((c) => c.isPrimaryKey).map((column) => newPrimitive(config, this.entity, column, table))[0] || fail(`No primary key found for ${table.name}`);
+		this.primitives = table.columns.filter((c) => !c.isPrimaryKey && !c.isForeignKey).filter((c) => !isEnumArray(c) && !isPgEnum(c)).map((column) => newPrimitive(config, this.entity, column, table)).filter((f) => !f.ignore);
+		this.enums = [...table.m2oRelations.filter((r) => isEnumTable(config, r.targetTable)).map((r) => newEnumField(config, this.entity, r, enums)).filter((f) => !f.ignore), ...table.columns.filter((c) => isEnumArray(c)).map((column) => newEnumArrayField(config, this.entity, column, enums)).filter((f) => !f.ignore)];
+		this.pgEnums = table.columns.filter((c) => isPgEnum(c)).map((column) => newPgEnumField(config, this.entity, column)).filter((f) => !f.ignore);
+		this.manyToOnes = table.m2oRelations.filter((r) => !isEnumTable(config, r.targetTable)).filter((r) => !isMultiColumnForeignKey(r)).filter((r) => !isComponentOfPolymorphicRelation(config, r)).filter((r) => !isBaseClassForeignKey(r)).map((r) => newManyToOneField(config, this.entity, r)).filter((f) => !f.ignore);
+		const allOneToManys = table.o2mRelations.filter((r) => !isJoinTable(config, r.targetTable)).filter((r) => !isMultiColumnForeignKey(r)).filter((r) => !isOneToOneRelation(r)).map((r) => newOneToMany(config, this.entity, r)).filter((f) => !isReactiveReference(config, f.otherEntity, f.otherFieldName)).filter((f) => !f.ignore);
+		this.oneToManys = allOneToManys.filter((f) => !f.isLargeCollection);
+		this.largeOneToManys = allOneToManys.filter((f) => f.isLargeCollection);
+		this.oneToOnes = table.o2mRelations.filter((r) => !isJoinTable(config, r.targetTable)).filter((r) => !isMultiColumnForeignKey(r)).filter((r) => !isBaseClassForeignKey(r)).filter((r) => isOneToOneRelation(r)).map((r) => newOneToOne(config, this.entity, r)).filter((f) => !f.ignore);
+		const allManyToManys = table.m2mRelations.filter((r) => isJoinTable(config, r.joinTable)).filter((r) => !isMultiColumnForeignKey(r)).filter((r) => !isEnumTable(config, r.targetTable)).map((r) => newManyToManyField(config, this.entity, r)).filter((f) => !f.ignore);
+		this.manyToManys = allManyToManys.filter((f) => !f.isLargeCollection);
+		this.largeManyToManys = allManyToManys.filter((f) => f.isLargeCollection);
+		this.manyToManyEnums = table.m2mRelations.filter((r) => isJoinTable(config, r.joinTable)).filter((r) => !isMultiColumnForeignKey(r)).filter((r) => isEnumTable(config, r.targetTable)).map((r) => newManyToManyEnumField(config, this.entity, r, enums)).filter((f) => !f.ignore);
+		this.polymorphics = polymorphicRelations(config, table).map((rc) => newPolymorphicField(config, table, this.entity, rc));
+		const modeledColumns = /* @__PURE__ */ new Set([
+			this.primaryKey.columnName,
+			...this.primitives.map((field) => field.columnName),
+			...this.enums.map((field) => field.columnName),
+			...this.pgEnums.map((field) => field.columnName),
+			...this.manyToOnes.map((field) => field.columnName),
+			...this.polymorphics.flatMap((field) => field.components.map((component) => component.columnName))
+		]);
+		this.ignoredColumns = table.columns.filter((column) => !modeledColumns.has(column.name)).map((column) => newPhysicalColumn(config, this.entity, column));
+		this.tableName = table.name;
+		this.tagName = config.entities[this.entity.name]?.tag;
+		this.abstract = config.entities[this.entity.name]?.abstract || false;
+		const { createdAtConf, updatedAtConf, deletedAtConf } = getTimestampConfig(config);
+		this.createdAt = this.primitives.find((f) => createdAtConf.names.includes(f.columnName));
+		this.updatedAt = this.primitives.find((f) => updatedAtConf.names.includes(f.columnName));
+		this.deletedAt = this.primitives.find((f) => deletedAtConf.names.includes(f.columnName));
+		this.uniqueConstraints = inferUniqueConstraints(this, table);
+		this.supportsEmExecute = table.primaryKey?.columns.length === 1 && this.primaryKey.columnName === "id" && table.columns.every((column) => column.arrayDimension <= 1 && !(isArray(column) && isPgEnum(column))) && ![...this.primitives, ...this.ignoredColumns].some((field) => field.isArray && !field.customSerde && (field.columnType === "jsonb" || !config.temporal && (field.columnType === "date" || field.columnType === "timestamp with time zone" || field.columnType === "timestamp without time zone")));
+	}
+	get name() {
+		return this.entity.name;
+	}
+	get nonDeferredFks() {
+		return [...this.manyToOnes.filter((r) => !r.isDeferredAndDeferrable), ...this.polymorphics.flatMap((p) => p.components).filter((c) => !c.isDeferredAndDeferrable)];
+	}
+	get nonDeferredManyToManyFks() {
+		return this.manyToManys.filter((r) => !r.isDeferredAndDeferrable);
+	}
+};
 function isMultiColumnForeignKey(r) {
-    return r.foreignKey.columns.length > 1;
+	return r.foreignKey.columns.length > 1;
 }
 function isBaseClassForeignKey(r) {
-    return r.foreignKey.columns.length === 1 && r.foreignKey.columns[0].name === "id";
+	return r.foreignKey.columns.length === 1 && r.foreignKey.columns[0].name === "id";
 }
 function isOneToOneRelation(r) {
-    // otherColumn will be the images.book_id in the other table
-    const otherColumn = r.foreignKey.columns[0];
-    // r.foreignKey.index is the index on _us_ (i.e. our Book primary key), so look up indexes in the target table
-    const indexes = r.targetTable.columns.find((c) => c.name == otherColumn.name)?.uniqueIndexes || [];
-    return indexes.find(isOneToOneIndex) !== undefined;
+	const otherColumn = r.foreignKey.columns[0];
+	return (r.targetTable.columns.find((c) => c.name == otherColumn.name)?.uniqueIndexes || []).find(isOneToOneIndex) !== void 0;
 }
-// If the unique index has only one column and is NOT a partial index, it's a one-to-one
 function isOneToOneIndex(i) {
-    return i.columns.length === 1 && !i.isPartial;
+	return i.columns.length === 1 && !i.isPartial;
 }
 /** Infers field names from unique constraints, i.e. `(author_id, title)` becomes `author, title`. */
 function inferUniqueConstraints(meta, table) {
-    return table.uniqueConstraints.flatMap((constraint) => {
-        if (constraint.index.isPartial)
-            return [];
-        const fields = Array.from(constraint.columns).map((column) => fieldNameForColumn(meta, column.name));
-        if (fields.some((field) => field === undefined))
-            return [];
-        return [fields];
-    });
+	return table.uniqueConstraints.flatMap((constraint) => {
+		if (constraint.index.isPartial) return [];
+		const fields = Array.from(constraint.columns).map((column) => fieldNameForColumn(meta, column.name));
+		if (fields.some((field) => field === void 0)) return [];
+		return [fields];
+	});
 }
 /** Returns the queryable field name for a unique constraint column. */
 function fieldNameForColumn(meta, columnName) {
-    const primitive = meta.primitives.find((field) => field.columnName === columnName);
-    if (primitive && !primitive.derived && !primitive.isArray && !primitive.customSerde)
-        return primitive.fieldName;
-    const enumField = meta.enums.find((field) => field.columnName === columnName);
-    if (enumField && !enumField.derived && !enumField.isArray)
-        return enumField.fieldName;
-    const pgEnum = meta.pgEnums.find((field) => field.columnName === columnName);
-    if (pgEnum)
-        return pgEnum.fieldName;
-    const manyToOne = meta.manyToOnes.find((field) => field.columnName === columnName);
-    if (manyToOne && !manyToOne.derived)
-        return manyToOne.fieldName;
-    return undefined;
+	const primitive = meta.primitives.find((field) => field.columnName === columnName);
+	if (primitive && !primitive.derived && !primitive.isArray && !primitive.customSerde) return primitive.fieldName;
+	const enumField = meta.enums.find((field) => field.columnName === columnName);
+	if (enumField && !enumField.derived && !enumField.isArray) return enumField.fieldName;
+	const pgEnum = meta.pgEnums.find((field) => field.columnName === columnName);
+	if (pgEnum) return pgEnum.fieldName;
+	const manyToOne = meta.manyToOnes.find((field) => field.columnName === columnName);
+	if (manyToOne && !manyToOne.derived) return manyToOne.fieldName;
 }
 function polymorphicRelations(config, table) {
-    const entity = config.entities[(0, utils_1.tableToEntityName)(config, table)];
-    return Object.entries(entity?.relations ?? {})
-        .filter(([, r]) => r.polymorphic)
-        .map(([fieldName, { polymorphic }]) => ({ fieldName, notNull: polymorphic === "notNull" }));
+	const entity = config.entities[tableToEntityName(config, table)];
+	return Object.entries(entity?.relations ?? {}).filter(([, r]) => r.polymorphic).map(([fieldName, { polymorphic }]) => ({
+		fieldName,
+		notNull: polymorphic === "notNull"
+	}));
 }
 function polymorphicFieldName(config, r) {
-    const { name } = r.foreignKey.columns[0];
-    const table = r.type === "m2o" ? r.sourceTable : r.targetTable;
-    return polymorphicRelations(config, table).find((pr) => name.startsWith(`${(0, change_case_1.snakeCase)(pr.fieldName)}_`))?.fieldName;
+	const { name } = r.foreignKey.columns[0];
+	return polymorphicRelations(config, r.type === "m2o" ? r.sourceTable : r.targetTable).find((pr) => name.startsWith(`${snakeCase(pr.fieldName)}_`))?.fieldName;
 }
 function isComponentOfPolymorphicRelation(config, r) {
-    return polymorphicFieldName(config, r) !== undefined;
+	return polymorphicFieldName(config, r) !== void 0;
 }
 function determineUserType(fieldType, superstruct, zodSchema, userFieldType) {
-    if (fieldType === "Object" && superstruct) {
-        return superstructType(superstruct);
-    }
-    if (fieldType === "Object" && zodSchema) {
-        return zodSchemaType(zodSchema);
-    }
-    if (userFieldType) {
-        return userFieldTypeType(userFieldType);
-    }
-    return fieldType;
+	if (fieldType === "Object" && superstruct) return superstructType(superstruct);
+	if (fieldType === "Object" && zodSchema) return zodSchemaType(zodSchema);
+	if (userFieldType) return userFieldTypeType(userFieldType);
+	return fieldType;
 }
 function newPrimitive(config, entity, column, table) {
-    const fieldName = primitiveFieldName(column.name);
-    const columnName = column.name;
-    const columnType = (column.type.shortName || column.type.name);
-    const array = isArray(column);
-    const fieldType = mapType(config, table.name, columnName, columnType);
-    const customSerde = (0, config_1.serdeConfig)(config, entity, fieldName);
-    const superstruct = (0, config_1.superstructConfig)(config, entity, fieldName);
-    const zodSchema = (0, config_1.zodSchemaConfig)(config, entity, fieldName);
-    const userFieldType = (0, config_1.fieldTypeConfig)(config, entity, fieldName);
-    const maybeUserType = determineUserType(fieldType, superstruct, zodSchema, userFieldType);
-    const unique = column.uniqueIndexes.find(isOneToOneIndex) !== undefined;
-    const hasConfigDefault = (0, config_1.isFieldHasDefault)(config, entity, fieldName);
-    return {
-        kind: "primitive",
-        fieldName,
-        columnName,
-        columnType,
-        fieldType: array ? (0, ts_poet_1.code) `${fieldType}[]` : maybeUserType,
-        rawFieldType: fieldType,
-        notNull: column.notNull,
-        columnDefault: column.default,
-        derived: fieldDerived(config, entity, fieldName),
-        protected: (0, config_1.isProtected)(config, entity, fieldName),
-        unique,
-        ignore: (0, config_1.isFieldIgnored)(config, entity, fieldName, column.notNull, column.default !== null),
-        superstruct: fieldType === "Object" && superstruct ? ts_poet_1.Import.from(superstruct) : undefined,
-        zodSchema: fieldType === "Object" && zodSchema ? ts_poet_1.Import.from(zodSchema) : undefined,
-        customSerde: customSerde ? serdeType(customSerde) : undefined,
-        isArray: array,
-        hasConfigDefault, // can be set to true by scanEntityFiles
-    };
+	const fieldName = primitiveFieldName(column.name);
+	const columnName = column.name;
+	const columnType = column.type.shortName || column.type.name;
+	const array = isArray(column);
+	const fieldType = mapType(config, table.name, columnName, columnType);
+	const customSerde = serdeConfig(config, entity, fieldName);
+	const superstruct = superstructConfig(config, entity, fieldName);
+	const zodSchema = zodSchemaConfig(config, entity, fieldName);
+	const maybeUserType = determineUserType(fieldType, superstruct, zodSchema, fieldTypeConfig(config, entity, fieldName));
+	const unique = column.uniqueIndexes.find(isOneToOneIndex) !== void 0;
+	const hasConfigDefault = isFieldHasDefault(config, entity, fieldName);
+	return {
+		kind: "primitive",
+		columnOwner: entity,
+		columnNotNull: column.notNull,
+		fieldName,
+		columnName,
+		columnType,
+		fieldType: array ? code`${maybeUserType}[]` : maybeUserType,
+		rawFieldType: fieldType,
+		notNull: column.notNull,
+		columnDefault: column.default,
+		columnGenerated: column.isGenerated,
+		derived: fieldDerived(config, entity, fieldName),
+		protected: isProtected(config, entity, fieldName),
+		unique,
+		ignore: isFieldIgnored(config, entity, fieldName, column.notNull, column.default !== null),
+		superstruct: fieldType === "Object" && superstruct ? Import.from(superstruct) : void 0,
+		zodSchema: fieldType === "Object" && zodSchema ? Import.from(zodSchema) : void 0,
+		customSerde: customSerde ? serdeType(customSerde) : void 0,
+		isArray: array,
+		hasConfigDefault,
+		lazy: isLazyField(config, entity, fieldName)
+	};
+}
+/** Keeps an ignored column's database type without applying entity-only field configuration. */
+function newPhysicalColumn(config, entity, column) {
+	const columnType = column.type.shortName || column.type.name;
+	const rawFieldType = column.type instanceof EnumType ? "string" : mapSimpleDbTypeToTypescriptType(config, columnType);
+	const isArray = column.arrayDimension === 1;
+	return {
+		kind: "primitive",
+		columnOwner: entity,
+		columnNotNull: column.notNull,
+		fieldName: primitiveFieldName(column.name),
+		columnName: column.name,
+		columnType,
+		fieldType: isArray ? code`${rawFieldType}[]` : rawFieldType,
+		rawFieldType,
+		notNull: column.notNull,
+		columnDefault: column.default,
+		columnGenerated: column.isGenerated,
+		derived: false,
+		protected: false,
+		unique: false,
+		superstruct: void 0,
+		zodSchema: void 0,
+		customSerde: void 0,
+		isArray,
+		hasConfigDefault: false
+	};
 }
 function fieldDerived(config, entity, fieldName) {
-    if (config_1.ormMaintainedFields.includes(fieldName)) {
-        return "orm";
-    }
-    else if ((0, config_1.isGetterField)(config, entity, fieldName)) {
-        return "sync";
-    }
-    else if ((0, config_1.isReactiveField)(config, entity, fieldName)) {
-        return "async";
-    }
-    else {
-        return false;
-    }
+	if (ormMaintainedFields.includes(fieldName)) return "orm";
+	else if (isGetterField(config, entity, fieldName)) return "sync";
+	else if (isReactiveField(config, entity, fieldName)) return "async";
+	else return false;
 }
 function fkFieldDerived(config, entity, fieldName) {
-    if ((0, config_1.isReactiveReference)(config, entity, fieldName)) {
-        return "async";
-    }
-    else {
-        return false;
-    }
+	if (isReactiveReference(config, entity, fieldName)) return "async";
+	else return false;
 }
 function newEnumField(config, entity, r, enums) {
-    const column = r.foreignKey.columns[0];
-    const columnName = column.name;
-    const columnType = (column.type.shortName || column.type.name);
-    const fieldName = enumFieldName(column.name);
-    const enumName = (0, utils_1.tableToEntityName)(config, r.targetTable);
-    const enumType = (0, ts_poet_1.imp)(`${enumName}@./entities.ts`);
-    const enumDetailType = (0, ts_poet_1.imp)(`${(0, pluralize_1.plural)(enumName)}@./entities.ts`);
-    const enumDetailsType = (0, ts_poet_1.imp)(`${enumName}Details@./entities.ts`);
-    const notNull = column.notNull;
-    const ignore = (0, config_1.isFieldIgnored)(config, entity, fieldName, notNull, column.default !== null);
-    const hasConfigDefault = (0, config_1.isFieldHasDefault)(config, entity, fieldName);
-    return {
-        kind: "enum",
-        fieldName,
-        columnName,
-        columnType,
-        columnDefault: column.default,
-        derived: fieldDerived(config, entity, fieldName),
-        enumName,
-        enumType,
-        enumDetailType,
-        enumDetailsType,
-        notNull,
-        ignore,
-        enumRows: enums[r.targetTable.name].rows,
-        isArray: false,
-        hasConfigDefault, // can be set to true by scanEntityFiles
-    };
+	const column = r.foreignKey.columns[0];
+	const columnName = column.name;
+	const columnType = column.type.shortName || column.type.name;
+	const fieldName = enumFieldName(column.name);
+	const enumName = tableToEntityName(config, r.targetTable);
+	const enumType = imp(`${enumName}@./entities.ts`);
+	const enumDetailType = imp(`${plural(enumName)}@./entities.ts`);
+	const enumDetailsType = imp(`${enumName}Details@./entities.ts`);
+	const notNull = column.notNull;
+	const ignore = isFieldIgnored(config, entity, fieldName, notNull, column.default !== null);
+	const hasConfigDefault = isFieldHasDefault(config, entity, fieldName);
+	return {
+		kind: "enum",
+		columnOwner: entity,
+		columnNotNull: column.notNull,
+		fieldName,
+		columnName,
+		columnType,
+		columnDefault: column.default,
+		columnGenerated: column.isGenerated,
+		derived: fieldDerived(config, entity, fieldName),
+		enumName,
+		enumType,
+		enumDetailType,
+		enumDetailsType,
+		notNull,
+		ignore,
+		enumRows: enums[r.targetTable.name].rows,
+		isArray: false,
+		hasConfigDefault
+	};
 }
 function newEnumArrayField(config, entity, column, enums) {
-    const columnName = column.name;
-    const columnType = (column.type.shortName || column.type.name);
-    const fieldName = enumFieldName(column.name);
-    // Find the enum table name via the comment hint (instead of a FK constraint), and strip the enum= prefix
-    const enumTable = column.comment.replace("enum=", "");
-    const enumName = (enums[enumTable] || (0, utils_1.fail)(`Could not find enum ${enumTable}`)).name;
-    const enumType = (0, ts_poet_1.imp)(`${enumName}@./entities.ts`);
-    const enumDetailType = (0, ts_poet_1.imp)(`${(0, pluralize_1.plural)(enumName)}@./entities.ts`);
-    const enumDetailsType = (0, ts_poet_1.imp)(`${enumName}Details@./entities.ts`);
-    const notNull = column.notNull;
-    const ignore = (0, config_1.isFieldIgnored)(config, entity, fieldName, notNull, column.default !== null);
-    const hasConfigDefault = (0, config_1.isFieldHasDefault)(config, entity, fieldName);
-    return {
-        kind: "enum",
-        fieldName,
-        columnName,
-        columnType,
-        columnDefault: column.default,
-        derived: fieldDerived(config, entity, fieldName),
-        enumName,
-        enumType,
-        enumDetailType,
-        enumDetailsType,
-        notNull,
-        ignore,
-        enumRows: enums[enumTable].rows,
-        isArray: true,
-        hasConfigDefault, // can be set to true by scanEntityFiles
-    };
+	const columnName = column.name;
+	const columnType = column.type.shortName || column.type.name;
+	const fieldName = enumFieldName(column.name);
+	const enumTable = column.comment.replace("enum=", "");
+	const enumName = (enums[enumTable] || fail(`Could not find enum ${enumTable}`)).name;
+	const enumType = imp(`${enumName}@./entities.ts`);
+	const enumDetailType = imp(`${plural(enumName)}@./entities.ts`);
+	const enumDetailsType = imp(`${enumName}Details@./entities.ts`);
+	const notNull = column.notNull;
+	const ignore = isFieldIgnored(config, entity, fieldName, notNull, column.default !== null);
+	const hasConfigDefault = isFieldHasDefault(config, entity, fieldName);
+	return {
+		kind: "enum",
+		columnOwner: entity,
+		columnNotNull: column.notNull,
+		fieldName,
+		columnName,
+		columnType,
+		columnDefault: column.default,
+		columnGenerated: column.isGenerated,
+		derived: fieldDerived(config, entity, fieldName),
+		enumName,
+		enumType,
+		enumDetailType,
+		enumDetailsType,
+		notNull,
+		ignore,
+		enumRows: enums[enumTable].rows,
+		isArray: true,
+		hasConfigDefault
+	};
 }
 function newPgEnumField(config, entity, column) {
-    const fieldName = primitiveFieldName(column.name);
-    const columnName = column.name;
-    const enumName = (0, change_case_1.pascalCase)(column.type.name);
-    const enumType = (0, ts_poet_1.imp)(`${enumName}@./entities.ts`);
-    const hasConfigDefault = (0, config_1.isFieldHasDefault)(config, entity, fieldName);
-    return {
-        kind: "pg-enum",
-        fieldName,
-        columnName,
-        dbType: column.type.name,
-        enumType,
-        enumName,
-        enumValues: column.type.values,
-        notNull: column.notNull,
-        columnDefault: column.default,
-        ignore: (0, config_1.isFieldIgnored)(config, entity, fieldName, column.notNull, column.default !== null),
-        hasConfigDefault, // can be set to true by scanEntityFiles
-    };
+	const fieldName = primitiveFieldName(column.name);
+	const columnName = column.name;
+	const enumName = pascalCase(column.type.name);
+	const enumType = imp(`${enumName}@./entities.ts`);
+	const hasConfigDefault = isFieldHasDefault(config, entity, fieldName);
+	return {
+		kind: "pg-enum",
+		columnOwner: entity,
+		columnNotNull: column.notNull,
+		fieldName,
+		columnName,
+		dbType: column.type.name,
+		enumType,
+		enumName,
+		enumValues: column.type.values,
+		notNull: column.notNull,
+		columnDefault: column.default,
+		columnGenerated: column.isGenerated,
+		ignore: isFieldIgnored(config, entity, fieldName, column.notNull, column.default !== null),
+		hasConfigDefault
+	};
 }
 function newManyToOneField(config, entity, r) {
-    const column = r.foreignKey.columns[0];
-    const columnName = column.name;
-    const dbType = r.foreignKey.columns[0].type.shortName;
-    const fieldName = referenceName(config, entity, r);
-    const otherEntity = makeEntity((0, utils_1.tableToEntityName)(config, r.targetTable));
-    const isOneToOne = column.uniqueIndexes.find(isOneToOneIndex) !== undefined;
-    const otherFieldName = isOneToOne
-        ? oneToOneName(config, otherEntity, entity, r)
-        : collectionName(config, otherEntity, entity, r).fieldName;
-    const notNull = column.notNull;
-    const ignore = (0, config_1.isFieldIgnored)(config, entity, fieldName, notNull, column.default !== null);
-    const isDeferredAndDeferrable = r.foreignKey.isDeferred && r.foreignKey.isDeferrable;
-    const derived = fkFieldDerived(config, entity, fieldName);
-    const hasConfigDefault = (0, config_1.isFieldHasDefault)(config, entity, fieldName);
-    return {
-        kind: "m2o",
-        fieldName,
-        columnName,
-        otherEntity,
-        otherFieldName,
-        notNull,
-        ignore,
-        derived,
-        dbType,
-        isDeferredAndDeferrable,
-        constraintName: r.foreignKey.name,
-        hasConfigDefault, // can be set to true by scanEntityFiles
-        onDelete: r.foreignKey.onDelete,
-    };
+	const column = r.foreignKey.columns[0];
+	const columnName = column.name;
+	const dbType = r.foreignKey.columns[0].type.shortName;
+	const fieldName = referenceName(config, entity, r);
+	const otherEntity = makeEntity(tableToEntityName(config, r.targetTable));
+	const otherFieldName = column.uniqueIndexes.find(isOneToOneIndex) !== void 0 ? oneToOneName(config, otherEntity, entity, r) : collectionName(config, otherEntity, entity, r).fieldName;
+	const notNull = column.notNull;
+	const ignore = isFieldIgnored(config, entity, fieldName, notNull, column.default !== null);
+	const isDeferredAndDeferrable = r.foreignKey.isDeferred && r.foreignKey.isDeferrable;
+	const derived = fkFieldDerived(config, entity, fieldName);
+	const hasConfigDefault = isFieldHasDefault(config, entity, fieldName);
+	return {
+		kind: "m2o",
+		columnOwner: entity,
+		columnNotNull: column.notNull,
+		fieldName,
+		columnName,
+		columnDefault: column.default,
+		columnGenerated: column.isGenerated,
+		otherEntity,
+		otherFieldName,
+		notNull,
+		ignore,
+		derived,
+		dbType,
+		isDeferredAndDeferrable,
+		constraintName: r.foreignKey.name,
+		hasConfigDefault,
+		onDelete: r.foreignKey.onDelete
+	};
 }
 function newOneToMany(config, entity, r) {
-    const column = r.foreignKey.columns[0];
-    // source == parent i.e. the reference of the foreign key column
-    // target == child i.e. the table with the foreign key column in it
-    const otherEntity = makeEntity((0, utils_1.tableToEntityName)(config, r.targetTable));
-    const { singularName, fieldName } = collectionName(config, entity, otherEntity, r);
-    const otherFieldName = referenceName(config, otherEntity, r);
-    const orderBy = config.entities[entity.name]?.relations?.[fieldName]?.orderBy ?? config.entities[otherEntity.name]?.orderBy;
-    return {
-        kind: "o2m",
-        fieldName,
-        singularName,
-        otherEntity,
-        otherFieldName,
-        otherColumnName: column.name,
-        otherColumnNotNull: column.notNull,
-        ignore: (0, config_1.isFieldIgnored)(config, entity, fieldName) || (0, config_1.isFieldIgnored)(config, otherEntity, otherFieldName),
-        isLargeCollection: (0, config_1.isLargeCollection)(config, entity, fieldName),
-        orderBy: (0, utils_1.parseOrder)(orderBy),
-    };
+	const column = r.foreignKey.columns[0];
+	const otherEntity = makeEntity(tableToEntityName(config, r.targetTable));
+	const { singularName, fieldName } = collectionName(config, entity, otherEntity, r);
+	const otherFieldName = referenceName(config, otherEntity, r);
+	const orderBy = config.entities[entity.name]?.relations?.[fieldName]?.orderBy ?? config.entities[otherEntity.name]?.orderBy;
+	return {
+		kind: "o2m",
+		fieldName,
+		singularName,
+		otherEntity,
+		otherFieldName,
+		otherColumnName: column.name,
+		otherColumnNotNull: column.notNull,
+		ignore: isFieldIgnored(config, entity, fieldName) || isFieldIgnored(config, otherEntity, otherFieldName),
+		isLargeCollection: isLargeCollection(config, entity, fieldName),
+		orderBy: parseOrder(orderBy),
+		softDeletes: softDeletesConfig(config, entity, fieldName)
+	};
 }
 function newOneToOne(config, entity, r) {
-    const column = r.foreignKey.columns[0];
-    // source == parent i.e. the reference of the foreign key column
-    // target == child i.e. the table with the foreign key column in it
-    const otherEntity = makeEntity((0, utils_1.tableToEntityName)(config, r.targetTable));
-    const fieldName = oneToOneName(config, entity, otherEntity, r);
-    const otherFieldName = referenceName(config, otherEntity, r);
-    const otherColumnName = column.name;
-    const otherColumnNotNull = column.notNull;
-    const ignore = (0, config_1.isFieldIgnored)(config, entity, fieldName) || (0, config_1.isFieldIgnored)(config, otherEntity, otherFieldName);
-    return { kind: "o2o", fieldName, otherEntity, otherFieldName, otherColumnName, otherColumnNotNull, ignore };
+	const column = r.foreignKey.columns[0];
+	const otherEntity = makeEntity(tableToEntityName(config, r.targetTable));
+	const fieldName = oneToOneName(config, entity, otherEntity, r);
+	const otherFieldName = referenceName(config, otherEntity, r);
+	return {
+		kind: "o2o",
+		fieldName,
+		otherEntity,
+		otherFieldName,
+		otherColumnName: column.name,
+		otherColumnNotNull: column.notNull,
+		ignore: isFieldIgnored(config, entity, fieldName) || isFieldIgnored(config, otherEntity, otherFieldName)
+	};
 }
 function newManyToManyField(config, entity, r) {
-    const { foreignKey, targetForeignKey, targetTable } = r;
-    const otherEntity = makeEntity((0, utils_1.tableToEntityName)(config, targetTable));
-    // For foo_to_bar.some_foo_id use the `some_foo_id` column i.e. `someFoos`
-    const fieldName = manyToManyName(targetForeignKey.columns[0]);
-    const otherFieldName = manyToManyName(foreignKey.columns[0]);
-    const isDeferredAndDeferrable = targetForeignKey.isDeferred && targetForeignKey.isDeferrable;
-    // Determine if this m2m is derived:
-    // - "async" if this side is explicitly marked as a ReactiveManyToMany
-    // - "otherSide" if the OTHER side is marked as a ReactiveManyToMany (making this the read-only other side)
-    // - false otherwise (regular m2m)
-    const isThisSideDerived = (0, config_1.isReactiveManyToMany)(config, entity, fieldName);
-    const isOtherSideDerived = (0, config_1.isReactiveManyToMany)(config, otherEntity, otherFieldName);
-    const derived = isThisSideDerived ? "async" : isOtherSideDerived ? "otherSide" : false;
-    return {
-        kind: "m2m",
-        joinTableName: r.joinTable.name,
-        fieldName,
-        singularName: (0, pluralize_1.singular)(fieldName),
-        columnName: foreignKey.columns[0].name,
-        otherEntity,
-        otherFieldName,
-        otherColumnName: targetForeignKey.columns[0].name,
-        ignore: (0, config_1.isFieldIgnored)(config, entity, fieldName) || (0, config_1.isFieldIgnored)(config, otherEntity, otherFieldName),
-        isLargeCollection: (0, config_1.isLargeCollection)(config, entity, fieldName),
-        isDeferredAndDeferrable,
-        derived,
-        hasJoinTableId: (0, utils_1.joinTableHasId)(r.joinTable),
-    };
+	const { foreignKey, targetForeignKey, targetTable } = r;
+	const otherEntity = makeEntity(tableToEntityName(config, targetTable));
+	const fieldName = manyToManyName(targetForeignKey.columns[0]);
+	const otherFieldName = manyToManyName(foreignKey.columns[0]);
+	const isDeferredAndDeferrable = targetForeignKey.isDeferred && targetForeignKey.isDeferrable;
+	const isThisSideDerived = isReactiveManyToMany(config, entity, fieldName);
+	const isOtherSideDerived = isReactiveManyToMany(config, otherEntity, otherFieldName);
+	const derived = isThisSideDerived ? "async" : isOtherSideDerived ? "otherSide" : false;
+	return {
+		kind: "m2m",
+		joinTableName: r.joinTable.name,
+		fieldName,
+		singularName: singular(fieldName),
+		columnName: foreignKey.columns[0].name,
+		otherEntity,
+		otherFieldName,
+		otherColumnName: targetForeignKey.columns[0].name,
+		ignore: isFieldIgnored(config, entity, fieldName) || isFieldIgnored(config, otherEntity, otherFieldName),
+		isLargeCollection: isLargeCollection(config, entity, fieldName),
+		isDeferredAndDeferrable,
+		derived,
+		softDeletes: softDeletesConfig(config, entity, fieldName),
+		hasJoinTableId: joinTableHasId(r.joinTable)
+	};
 }
 function newManyToManyEnumField(config, entity, r, enums) {
-    const { foreignKey, targetForeignKey, targetTable } = r;
-    // For publisher_logo_colors.logo_color_id use the `logo_color_id` column i.e. `logoColors`
-    const fieldName = manyToManyName(targetForeignKey.columns[0]);
-    const enumName = (0, utils_1.tableToEntityName)(config, targetTable);
-    return {
-        kind: "m2mEnum",
-        joinTableName: r.joinTable.name,
-        fieldName,
-        columnName: foreignKey.columns[0].name,
-        otherColumnName: targetForeignKey.columns[0].name,
-        enumName,
-        enumType: (0, ts_poet_1.imp)(`${enumName}@./entities.ts`),
-        enumDetailType: (0, ts_poet_1.imp)(`${(0, pluralize_1.plural)(enumName)}@./entities.ts`),
-        enumDetailsType: (0, ts_poet_1.imp)(`${enumName}Details@./entities.ts`),
-        enumRows: enums[targetTable.name].rows,
-        ignore: (0, config_1.isFieldIgnored)(config, entity, fieldName),
-        hasJoinTableId: (0, utils_1.joinTableHasId)(r.joinTable),
-    };
+	const { foreignKey, targetForeignKey, targetTable } = r;
+	const fieldName = manyToManyName(targetForeignKey.columns[0]);
+	const enumName = tableToEntityName(config, targetTable);
+	return {
+		kind: "m2mEnum",
+		joinTableName: r.joinTable.name,
+		fieldName,
+		columnName: foreignKey.columns[0].name,
+		otherColumnName: targetForeignKey.columns[0].name,
+		enumName,
+		enumType: imp(`${enumName}@./entities.ts`),
+		enumDetailType: imp(`${plural(enumName)}@./entities.ts`),
+		enumDetailsType: imp(`${enumName}Details@./entities.ts`),
+		enumRows: enums[targetTable.name].rows,
+		ignore: isFieldIgnored(config, entity, fieldName),
+		hasJoinTableId: joinTableHasId(r.joinTable)
+	};
 }
 function newPolymorphicField(config, table, entity, pr) {
-    const { fieldName, notNull } = pr;
-    const components = table.m2oRelations
-        .filter((r) => !(0, utils_1.isEnumTable)(config, r.targetTable))
-        .filter((r) => !isMultiColumnForeignKey(r))
-        .filter((r) => polymorphicFieldName(config, r) === fieldName)
-        .map((r) => newPolymorphicFieldComponent(config, entity, r));
-    const fieldType = `${entity.name}${(0, change_case_1.pascalCase)(fieldName)}`;
-    const hasConfigDefault = (0, config_1.isFieldHasDefault)(config, entity, fieldName);
-    return {
-        kind: "poly",
-        fieldName,
-        fieldType,
-        notNull,
-        components,
-        hasConfigDefault, // can be set to true by scanEntityFiles
-    };
+	const { fieldName, notNull } = pr;
+	const components = table.m2oRelations.filter((r) => !isEnumTable(config, r.targetTable)).filter((r) => !isMultiColumnForeignKey(r)).filter((r) => polymorphicFieldName(config, r) === fieldName).map((r) => newPolymorphicFieldComponent(config, entity, r));
+	return {
+		kind: "poly",
+		fieldName,
+		fieldType: `${entity.name}${pascalCase(fieldName)}`,
+		notNull,
+		components,
+		hasConfigDefault: isFieldHasDefault(config, entity, fieldName)
+	};
 }
 function newPolymorphicFieldComponent(config, entity, r) {
-    const column = r.foreignKey.columns[0];
-    const columnName = column.name;
-    const otherEntity = makeEntity((0, utils_1.tableToEntityName)(config, r.targetTable));
-    const isOneToOne = column.uniqueIndexes.find(isOneToOneIndex) !== undefined;
-    const otherFieldName = isOneToOne
-        ? oneToOneName(config, otherEntity, entity, r)
-        : collectionName(config, otherEntity, entity, r).fieldName;
-    const isDeferredAndDeferrable = r.foreignKey.isDeferred && r.foreignKey.isDeferrable;
-    return {
-        columnName,
-        otherEntity,
-        otherFieldName,
-        isDeferredAndDeferrable,
-        constraintName: r.foreignKey.name,
-        notNull: false,
-    };
+	const column = r.foreignKey.columns[0];
+	const columnName = column.name;
+	const otherEntity = makeEntity(tableToEntityName(config, r.targetTable));
+	return {
+		columnName,
+		columnOwner: entity,
+		otherEntity,
+		otherFieldName: column.uniqueIndexes.find(isOneToOneIndex) !== void 0 ? oneToOneName(config, otherEntity, entity, r) : collectionName(config, otherEntity, entity, r).fieldName,
+		isDeferredAndDeferrable: r.foreignKey.isDeferred && r.foreignKey.isDeferrable,
+		constraintName: r.foreignKey.name,
+		notNull: false
+	};
 }
 function isFieldNameOverrides(maybeOverride) {
-    return (maybeOverride !== null &&
-        !Array.isArray(maybeOverride) &&
-        typeof maybeOverride === "object" &&
-        Object.keys(maybeOverride).some((k) => k === "fieldName" || k === "otherFieldName"));
+	return maybeOverride !== null && !Array.isArray(maybeOverride) && typeof maybeOverride === "object" && Object.keys(maybeOverride).some((k) => k === "fieldName" || k === "otherFieldName");
 }
 /** Finds the field name for o2o side of a o2o/m2o. */
-function oneToOneName(config, 
-//  I.e. the Book for o2o Book.image <-- `images.book_id`
-refEntity, 
-// I.e. the Image for o2o Book.image <-- `images.book_id`
-keyEntity, r) {
-    // If the name is overridden then use that
-    const overrides = r.foreignKey.columns[0].commentData;
-    if (isFieldNameOverrides(overrides) && overrides.otherFieldName) {
-        return overrides.otherFieldName;
-    }
-    // For `comments.parent_book_review_id`, we would just use `BookReview.comment` as the name
-    // For `authors.draft_current_book_id`, we would just use `Book.author` as the name
-    // For `project_items.current_selection_id`, we would use `HomeownerSelection.currentProjectItem`
-    const refTable = r instanceof pg_structure_1.M2ORelation ? r.targetTable : r.sourceTable;
-    // Does the ref table have any m2o pointing table at the key table?
-    const found = refTable.m2oRelations.find((s) => (0, utils_1.tableToEntityName)(config, s.targetTable) === keyEntity.name);
-    // console.log({refTable: refTable.name, keyTable: keyTable.name, found: found?.name, fieldName});
-    if (!found) {
-        // If there aren't any m2os, just use the raw type name like `.image` or `.comment`
-        return (0, change_case_1.camelCase)(keyEntity.name);
-    }
-    else {
-        // If there is a m2o, assume we might conflict, and use the column name to at least be unique
-        // Start with `book` from `images.book_id` or `current_draft_book` from `authors.current_draft_book_id`
-        let fieldName = r.foreignKey.columns[0].name.replace(idSuffix, "");
-        // Suffix the new type that we're pointing to, to `current_draft_book_author`
-        fieldName = `${fieldName}_${keyEntity.name}`;
-        // And drop the `book`, to `current_draft__author`
-        fieldName = fieldName.replace(refEntity.name.toLowerCase(), "");
-        // Then camel case, to `currentDraftAuthor`
-        return (0, change_case_1.camelCase)(fieldName);
-    }
+function oneToOneName(config, refEntity, keyEntity, r) {
+	const overrides = r.foreignKey.columns[0].commentData;
+	if (isFieldNameOverrides(overrides) && overrides.otherFieldName) return overrides.otherFieldName;
+	if (!(r instanceof M2ORelation ? r.targetTable : r.sourceTable).m2oRelations.find((s) => tableToEntityName(config, s.targetTable) === keyEntity.name)) return camelCase(keyEntity.name);
+	else {
+		let fieldName = r.foreignKey.columns[0].name.replace(idSuffix, "");
+		fieldName = `${fieldName}_${keyEntity.name}`;
+		fieldName = fieldName.replace(refEntity.name.toLowerCase(), "");
+		return camelCase(fieldName);
+	}
 }
 const idSuffix = /_id$|Id$/;
 function referenceName(config, entity, r) {
-    const [column] = r.foreignKey.columns;
-    const overrides = column.commentData;
-    return (polymorphicFieldName(config, r) ??
-        // If the name is overridden then use that
-        (isFieldNameOverrides(overrides) ? overrides.fieldName : undefined) ??
-        (0, change_case_1.camelCase)(column.name.replace(idSuffix, "")));
+	const [column] = r.foreignKey.columns;
+	const overrides = column.commentData;
+	return polymorphicFieldName(config, r) ?? (isFieldNameOverrides(overrides) ? overrides.fieldName : void 0) ?? camelCase(column.name.replace(idSuffix, ""));
 }
 function enumFieldName(columnName) {
-    return (0, change_case_1.camelCase)(columnName.replace(idSuffix, ""));
+	return camelCase(columnName.replace(idSuffix, ""));
 }
 function primitiveFieldName(columnName) {
-    return (0, change_case_1.camelCase)(columnName);
+	return camelCase(columnName);
 }
 function manyToManyName(column) {
-    const overrides = column.commentData;
-    // If the name is overridden then use that
-    if (isFieldNameOverrides(overrides) && overrides.otherFieldName) {
-        return overrides.otherFieldName;
-    }
-    return (0, change_case_1.camelCase)((0, pluralize_1.plural)(column.name.replace(idSuffix, "")));
+	const overrides = column.commentData;
+	if (isFieldNameOverrides(overrides) && overrides.otherFieldName) return overrides.otherFieldName;
+	return camelCase(plural(column.name.replace(idSuffix, "")));
 }
 /** Returns the collection name to use on `entity` when referring to `otherEntity`s. */
-function collectionName(config, 
-// I.e. the Author for o2m Author.books --> books.author_id
-singleEntity, 
-// I.e. the Book for o2m Author.books --> books.author_id
-collectionEntity, r) {
-    const [column] = r.foreignKey.columns;
-    const overrides = column.commentData;
-    // If the name is overridden then use that, but also singularize it
-    if (isFieldNameOverrides(overrides) && overrides.otherFieldName) {
-        const fieldName = overrides.otherFieldName;
-        return { fieldName, singularName: (0, pluralize_1.singular)(fieldName) };
-    }
-    // I.e. if the m2o is `books.author_id`, use `Author.books` as the collection name (we pluralize at the end).
-    let singularName = collectionEntity.name;
-    // Check if we have multiple FKs from collectionEntity --> singleEntity and prefix with FK name if so
-    const sourceTable = r.type === "m2o" ? r.sourceTable : r.targetTable;
-    const targetTable = r.type === "m2o" ? r.targetTable : r.sourceTable;
-    // If `books.foo_author_id` and `books.bar_author_id` both exist
-    if (r.type !== "m2m" && sourceTable.m2oRelations.filter((r) => r.targetTable === targetTable).length > 1) {
-        // Use `fooAuthorBooks`, `barAuthorBooks`
-        singularName = `${column.name.replace(idSuffix, "")}_${singularName}`;
-    }
-    // If we've guessed `Book.bookReviews` based on `book_reviews.book_id` --> `bookReviews`, strip the `Book` prefix
-    if (singularName.length > singleEntity.name.length && singularName.startsWith(singleEntity.name)) {
-        singularName = singularName.substring(singleEntity.name.length);
-    }
-    // camelize the name
-    singularName = (0, change_case_1.camelCase)(singularName);
-    // and pluralize for fieldName
-    return { fieldName: (0, pluralize_1.plural)(singularName), singularName };
+function collectionName(config, singleEntity, collectionEntity, r) {
+	const [column] = r.foreignKey.columns;
+	const overrides = column.commentData;
+	if (isFieldNameOverrides(overrides) && overrides.otherFieldName) {
+		const fieldName = overrides.otherFieldName;
+		return {
+			fieldName,
+			singularName: singular(fieldName)
+		};
+	}
+	let singularName = collectionEntity.name;
+	const sourceTable = r.type === "m2o" ? r.sourceTable : r.targetTable;
+	const targetTable = r.type === "m2o" ? r.targetTable : r.sourceTable;
+	if (r.type !== "m2m" && sourceTable.m2oRelations.filter((r) => r.targetTable === targetTable).length > 1) singularName = `${column.name.replace(idSuffix, "")}_${singularName}`;
+	if (singularName.length > singleEntity.name.length && singularName.startsWith(singleEntity.name)) singularName = singularName.substring(singleEntity.name.length);
+	singularName = camelCase(singularName);
+	return {
+		fieldName: plural(singularName),
+		singularName
+	};
 }
 function failIfOverlappingFieldNames(entity) {
-    const allFields = [
-        entity.primaryKey,
-        ...entity.primitives,
-        ...entity.enums,
-        ...entity.pgEnums,
-        ...entity.manyToOnes,
-        ...entity.oneToManys,
-        ...entity.largeOneToManys,
-        ...entity.oneToOnes,
-        ...entity.manyToManys,
-        ...entity.largeManyToManys,
-        ...entity.manyToManyEnums,
-        ...entity.polymorphics,
-    ];
-    Object.entries((0, joist_utils_1.groupBy)(allFields, (f) => f.fieldName)).forEach(([fieldName, fields]) => {
-        if (fields.length > 1) {
-            throw new Error(`In ${entity.name}, found multiple fields named '${fieldName}': ${fields.map((f) => f.kind).join(" ")}`);
-        }
-    });
+	const allFields = [
+		entity.primaryKey,
+		...entity.primitives,
+		...entity.enums,
+		...entity.pgEnums,
+		...entity.manyToOnes,
+		...entity.oneToManys,
+		...entity.largeOneToManys,
+		...entity.oneToOnes,
+		...entity.manyToManys,
+		...entity.largeManyToManys,
+		...entity.manyToManyEnums,
+		...entity.polymorphics
+	];
+	Object.entries(groupBy(allFields, (f) => f.fieldName)).forEach(([fieldName, fields]) => {
+		if (fields.length > 1) throw new Error(`In ${entity.name}, found multiple fields named '${fieldName}': ${fields.map((f) => f.kind).join(" ")}`);
+	});
 }
 function makeEntity(entityName) {
-    // Default to the conventional names; `resolveNameConflicts` rewrites them if they collide.
-    const names = entitySymbolNames(entityName);
-    return {
-        name: entityName,
-        type: entityType(entityName),
-        typeSymbol: entityTypeSymbol(entityName),
-        typeForMetadataFile: entityTypeForMetadataFile(entityName),
-        metaName: metaName(entityName),
-        metaType: metaType(entityName),
-        idType: entityTypeImport(entityName, names.idName),
-        orderType: entityTypeImport(entityName, names.orderName),
-        optsType: entityTypeImport(entityName, names.optsName),
-        configConst: (0, ts_poet_1.imp)(`${(0, change_case_1.camelCase)(entityName)}Config@./entities.ts`, {
-            definedIn: `./codegen/${entityName}Codegen.ts`,
-        }),
-        ...names,
-    };
+	const names = entitySymbolNames(entityName);
+	return {
+		name: entityName,
+		type: entityType(entityName),
+		typeSymbol: entityTypeSymbol(entityName),
+		typeForMetadataFile: entityTypeForMetadataFile(entityName),
+		metaName: metaName(entityName),
+		metaType: metaType(entityName),
+		idType: entityTypeImport(entityName, names.idName),
+		orderType: entityTypeImport(entityName, names.orderName),
+		optsType: entityTypeImport(entityName, names.optsName),
+		configConst: imp(`${camelCase(entityName)}Config@./entities.ts`, { definedIn: `./codegen/${entityName}Codegen.ts` }),
+		...names
+	};
 }
 /**
- * Collapses the per-relation `otherEntity` copies down to the one primary `Entity` per name.
- *
- * `makeEntity` mints a fresh `Entity` for every relation's `otherEntity`, so each entity ends up with
- * many duplicate objects floating around. Pointing them all at the single `entitiesByName[name].entity`
- * instance means later passes (i.e. `resolveNameConflicts`) only have to update one object per name.
- *
- * Must run after inheritance, since STI/CTI specialization both adds and re-points `otherEntity`s.
- */
+* Collapses the per-relation `otherEntity` copies down to the one primary `Entity` per name.
+*
+* `makeEntity` mints a fresh `Entity` for every relation's `otherEntity`, so each entity ends up with
+* many duplicate objects floating around. Pointing them all at the single `entitiesByName[name].entity`
+* instance means later passes (i.e. `resolveNameConflicts`) only have to update one object per name.
+*
+* Must run after inheritance, since STI/CTI specialization both adds and re-points `otherEntity`s.
+*/
 function canonicalizeOtherEntities(db) {
-    const canonical = (other) => db.entitiesByName[other.name]?.entity ?? other;
-    for (const meta of db.entities) {
-        for (const field of [
-            ...meta.manyToOnes,
-            ...meta.oneToManys,
-            ...meta.largeOneToManys,
-            ...meta.oneToOnes,
-            ...meta.manyToManys,
-            ...meta.largeManyToManys,
-        ]) {
-            field.otherEntity = canonical(field.otherEntity);
-        }
-        for (const poly of meta.polymorphics) {
-            for (const comp of poly.components)
-                comp.otherEntity = canonical(comp.otherEntity);
-        }
-    }
+	const canonical = (other) => db.entitiesByName[other.name]?.entity ?? other;
+	for (const meta of db.entities) {
+		for (const field of [
+			...meta.manyToOnes,
+			...meta.oneToManys,
+			...meta.largeOneToManys,
+			...meta.oneToOnes,
+			...meta.manyToManys,
+			...meta.largeManyToManys
+		]) field.otherEntity = canonical(field.otherEntity);
+		for (const poly of meta.polymorphics) for (const comp of poly.components) comp.otherEntity = canonical(comp.otherEntity);
+		if (meta.physicalMetadata) canonicalizeOtherEntities({
+			...db,
+			entities: [meta.physicalMetadata]
+		});
+	}
 }
 /**
- * Rewrites codegen'd type names that collide with another exported type name.
- *
- * `makeEntity` defaults each name to the conventional `${name}<Suffix>`, but if a separate entity or
- * enum is literally named e.g. `AuthorScope` or `AuthorOrder`, our generated type of the same name
- * would collide with it, so we fall back to `Author_Scope` / `Author_Order`.
- *
- * Relies on `canonicalizeOtherEntities` having run, so mutating each primary `meta.entity` also updates
- * the `otherEntity` references that point at it (e.g. `Book.author: AuthorId` follows `Author`'s rename).
- */
+* Rewrites codegen'd type names that collide with another exported type name.
+*
+* `makeEntity` defaults each name to the conventional `${name}<Suffix>`, but if a separate entity or
+* enum is literally named e.g. `AuthorScope` or `AuthorOrder`, our generated type of the same name
+* would collide with it, so we fall back to `Author_Scope` / `Author_Order`.
+*
+* Relies on `canonicalizeOtherEntities` having run, so mutating each primary `meta.entity` also updates
+* the `otherEntity` references that point at it (e.g. `Book.author: AuthorId` follows `Author`'s rename).
+*/
 function resolveNameConflicts(config, db) {
-    // The names exported into `entities.ts` that a codegen'd type could shadow.
-    const reserved = new Set(db.entities.map((meta) => meta.name));
-    for (const enumData of Object.values(db.enums)) {
-        // An enum table exports its (singularized) type, its `Details` type/const, and its pluralized const,
-        // i.e. `ChangeRequestAssetScope`, `ChangeRequestAssetScopeDetails`, and `ChangeRequestAssetScopes`.
-        const enumName = (0, utils_1.tableToEntityName)(config, enumData.table);
-        reserved.add(enumName).add(`${enumName}Details`).add((0, pluralize_1.plural)(enumName));
-    }
-    for (const pgEnum of Object.values(db.pgEnums))
-        reserved.add(pgEnum.name);
-    for (const meta of db.entities) {
-        if (hasNameConflict(meta.name, reserved))
-            applyEntityNames(meta.entity, reserved);
-    }
+	const reserved = new Set(db.entities.map((meta) => meta.name));
+	for (const enumData of Object.values(db.enums)) {
+		const enumName = tableToEntityName(config, enumData.table);
+		reserved.add(enumName).add(`${enumName}Details`).add(plural(enumName));
+	}
+	for (const pgEnum of Object.values(db.pgEnums)) reserved.add(pgEnum.name);
+	for (const meta of db.entities) if (hasNameConflict(meta.name, reserved)) applyEntityNames(meta.entity, reserved);
 }
 /** Computes the codegen'd type names for an entity, underscoring any that `reserved` already contains. */
 function entitySymbolNames(name, reserved) {
-    const pick = (suffix) => (reserved?.has(`${name}${suffix}`) ? `${name}_${suffix}` : `${name}${suffix}`);
-    return {
-        idName: pick("Id"),
-        fieldsName: pick("Fields"),
-        optsName: pick("Opts"),
-        idsOptsName: pick("IdsOpts"),
-        filterName: pick("Filter"),
-        graphqlFilterName: pick("GraphQLFilter"),
-        orderName: pick("Order"),
-        factoryExtrasName: pick("FactoryExtras"),
-        scopeName: pick("Scope"),
-        scopesName: pick("Scopes"),
-    };
+	const pick = (suffix) => reserved?.has(`${name}${suffix}`) ? `${name}_${suffix}` : `${name}${suffix}`;
+	return {
+		idName: pick("Id"),
+		fieldsName: pick("Fields"),
+		optsName: pick("Opts"),
+		idsOptsName: pick("IdsOpts"),
+		filterName: pick("Filter"),
+		graphqlFilterName: pick("GraphQLFilter"),
+		orderName: pick("Order"),
+		factoryExtrasName: pick("FactoryExtras"),
+		scopeName: pick("Scope"),
+		scopesName: pick("Scopes")
+	};
 }
 /** Returns true if any of the entity's conventional type names is already taken. */
 function hasNameConflict(name, reserved) {
-    return Object.values(entitySymbolNames(name)).some((conventional) => reserved.has(conventional));
+	return Object.values(entitySymbolNames(name)).some((conventional) => reserved.has(conventional));
 }
 /** Rewrites an entity's type names (and the `Import`s built from them) to their de-conflicted form. */
 function applyEntityNames(entity, reserved) {
-    const names = entitySymbolNames(entity.name, reserved);
-    Object.assign(entity, names);
-    entity.idType = entityTypeImport(entity.name, names.idName);
-    entity.orderType = entityTypeImport(entity.name, names.orderName);
-    entity.optsType = entityTypeImport(entity.name, names.optsName);
+	const names = entitySymbolNames(entity.name, reserved);
+	Object.assign(entity, names);
+	entity.idType = entityTypeImport(entity.name, names.idName);
+	entity.orderType = entityTypeImport(entity.name, names.orderName);
+	entity.optsType = entityTypeImport(entity.name, names.optsName);
 }
 function entityTypeImport(entityName, symbolName) {
-    return (0, ts_poet_1.imp)(`t:${symbolName}@./entities.ts`, { definedIn: `./codegen/${entityName}Codegen.ts` });
+	return imp(`t:${symbolName}@./entities.ts`, { definedIn: `./codegen/${entityName}Codegen.ts` });
 }
 function metaName(entityName) {
-    return `${(0, change_case_1.camelCase)(entityName)}Meta`;
+	return `${camelCase(entityName)}Meta`;
 }
 function metaType(entityName) {
-    return (0, ts_poet_1.imp)(`${metaName(entityName)}@./entities.ts`);
+	return imp(`${metaName(entityName)}@./entities.ts`);
 }
 function entityType(entityName) {
-    return (0, ts_poet_1.imp)(`t:${entityName}@./entities.ts`);
+	return imp(`t:${entityName}@./entities.ts`);
 }
 function entityTypeSymbol(entityName) {
-    return (0, ts_poet_1.imp)(`${entityName}@./entities.ts`);
+	return imp(`${entityName}@./entities.ts`);
 }
 function entityTypeForMetadataFile(entityName) {
-    return (0, ts_poet_1.imp)(`${entityName}@./${entityName}.ts`);
+	return imp(`${entityName}@./${entityName}.ts`);
 }
 function mapType(config, tableName, columnName, dbColumnType) {
-    return (0, utils_1.mapSimpleDbTypeToTypescriptType)(config, dbColumnType);
+	return mapSimpleDbTypeToTypescriptType(config, dbColumnType);
 }
 function isEnumArray(c) {
-    return c.arrayDimension === 1 && !!c.comment && c.comment.startsWith("enum=");
+	return c.arrayDimension === 1 && !!c.comment && c.comment.startsWith("enum=");
 }
 function isArray(c) {
-    return c.arrayDimension === 1;
+	return c.arrayDimension === 1;
 }
 function isPgEnum(c) {
-    return c.type instanceof pg_structure_1.EnumType;
+	return c.type instanceof EnumType;
 }
 function superstructType(s) {
-    // Assume it's `foo@...`, turn it into `Foo@...`
-    const [symbol, ...path] = s.split("@");
-    return ts_poet_1.Import.from(`${(0, change_case_1.pascalCase)(symbol)}@${path.join("@")}`);
+	const [symbol, ...path] = s.split("@");
+	return Import.from(`${pascalCase(symbol)}@${path.join("@")}`);
 }
 function zodSchemaType(s) {
-    const schema = ts_poet_1.Import.from(s);
-    return (0, ts_poet_1.code) `${symbols_1.Zod}.input<typeof ${schema}>`;
+	const schema = Import.from(s);
+	return code`${Zod}.input<typeof ${schema}>`;
 }
 function userFieldTypeType(s) {
-    return ts_poet_1.Import.from(`t:${s}`);
+	return Import.from(`t:${s}`);
 }
 function serdeType(s) {
-    return ts_poet_1.Import.from(s);
+	return Import.from(s);
 }
+//#endregion
+export { EntityDbMetadata, canonicalizeOtherEntities, collectionName, failIfOverlappingFieldNames, makeEntity, manyToManyName, oneToOneName, referenceName, resolveNameConflicts };
+
 //# sourceMappingURL=EntityDbMetadata.js.map