joist-codegen 2.3.0 → 2.4.0

package/build/EntityDbMetadata.cjs

@@ -0,0 +1,672 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_pgMetadata = require("./pgMetadata.cjs");
+const require_utils = require("./utils.cjs");
+const require_config = require("./config.cjs");
+const require_symbols = require("./symbols.cjs");
+require("./loadMetadata.cjs");
+let change_case = require("change-case");
+let joist_utils = require("joist-utils");
+let pluralize = require("pluralize");
+pluralize = require_runtime.__toESM(pluralize, 1);
+let ts_poet = require("ts-poet");
+//#region src/EntityDbMetadata.ts
+const { plural, singular } = pluralize.default;
+/** 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(require_utils.tableToEntityName(config, table));
+		if (require_utils.isSubClassTable(table)) {
+			this.baseClassName = require_utils.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] || require_utils.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) => require_utils.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) => !require_utils.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) => !require_utils.isJoinTable(config, r.targetTable)).filter((r) => !isMultiColumnForeignKey(r)).filter((r) => !isOneToOneRelation(r)).map((r) => newOneToMany(config, this.entity, r)).filter((f) => !require_config.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) => !require_utils.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) => require_utils.isJoinTable(config, r.joinTable)).filter((r) => !isMultiColumnForeignKey(r)).filter((r) => !require_utils.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) => require_utils.isJoinTable(config, r.joinTable)).filter((r) => !isMultiColumnForeignKey(r)).filter((r) => require_utils.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 } = require_config.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;
+}
+function isBaseClassForeignKey(r) {
+	return r.foreignKey.columns.length === 1 && r.foreignKey.columns[0].name === "id";
+}
+function isOneToOneRelation(r) {
+	const otherColumn = r.foreignKey.columns[0];
+	return (r.targetTable.columns.find((c) => c.name == otherColumn.name)?.uniqueIndexes || []).find(isOneToOneIndex) !== void 0;
+}
+function isOneToOneIndex(i) {
+	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 === 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;
+}
+function polymorphicRelations(config, table) {
+	const entity = config.entities[require_utils.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];
+	return polymorphicRelations(config, r.type === "m2o" ? r.sourceTable : r.targetTable).find((pr) => name.startsWith(`${(0, change_case.snakeCase)(pr.fieldName)}_`))?.fieldName;
+}
+function isComponentOfPolymorphicRelation(config, r) {
+	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;
+}
+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 = require_config.serdeConfig(config, entity, fieldName);
+	const superstruct = require_config.superstructConfig(config, entity, fieldName);
+	const zodSchema = require_config.zodSchemaConfig(config, entity, fieldName);
+	const maybeUserType = determineUserType(fieldType, superstruct, zodSchema, require_config.fieldTypeConfig(config, entity, fieldName));
+	const unique = column.uniqueIndexes.find(isOneToOneIndex) !== void 0;
+	const hasConfigDefault = require_config.isFieldHasDefault(config, entity, fieldName);
+	return {
+		kind: "primitive",
+		columnOwner: entity,
+		columnNotNull: column.notNull,
+		fieldName,
+		columnName,
+		columnType,
+		fieldType: array ? ts_poet.code`${maybeUserType}[]` : maybeUserType,
+		rawFieldType: fieldType,
+		notNull: column.notNull,
+		columnDefault: column.default,
+		columnGenerated: column.isGenerated,
+		derived: fieldDerived(config, entity, fieldName),
+		protected: require_config.isProtected(config, entity, fieldName),
+		unique,
+		ignore: require_config.isFieldIgnored(config, entity, fieldName, column.notNull, column.default !== null),
+		superstruct: fieldType === "Object" && superstruct ? ts_poet.Import.from(superstruct) : void 0,
+		zodSchema: fieldType === "Object" && zodSchema ? ts_poet.Import.from(zodSchema) : void 0,
+		customSerde: customSerde ? serdeType(customSerde) : void 0,
+		isArray: array,
+		hasConfigDefault,
+		lazy: require_config.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 require_pgMetadata.EnumType ? "string" : require_utils.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 ? ts_poet.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 (require_config.ormMaintainedFields.includes(fieldName)) return "orm";
+	else if (require_config.isGetterField(config, entity, fieldName)) return "sync";
+	else if (require_config.isReactiveField(config, entity, fieldName)) return "async";
+	else return false;
+}
+function fkFieldDerived(config, entity, fieldName) {
+	if (require_config.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 = require_utils.tableToEntityName(config, r.targetTable);
+	const enumType = (0, ts_poet.imp)(`${enumName}@./entities.ts`);
+	const enumDetailType = (0, ts_poet.imp)(`${plural(enumName)}@./entities.ts`);
+	const enumDetailsType = (0, ts_poet.imp)(`${enumName}Details@./entities.ts`);
+	const notNull = column.notNull;
+	const ignore = require_config.isFieldIgnored(config, entity, fieldName, notNull, column.default !== null);
+	const hasConfigDefault = require_config.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);
+	const enumTable = column.comment.replace("enum=", "");
+	const enumName = (enums[enumTable] || require_utils.fail(`Could not find enum ${enumTable}`)).name;
+	const enumType = (0, ts_poet.imp)(`${enumName}@./entities.ts`);
+	const enumDetailType = (0, ts_poet.imp)(`${plural(enumName)}@./entities.ts`);
+	const enumDetailsType = (0, ts_poet.imp)(`${enumName}Details@./entities.ts`);
+	const notNull = column.notNull;
+	const ignore = require_config.isFieldIgnored(config, entity, fieldName, notNull, column.default !== null);
+	const hasConfigDefault = require_config.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.pascalCase)(column.type.name);
+	const enumType = (0, ts_poet.imp)(`${enumName}@./entities.ts`);
+	const hasConfigDefault = require_config.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: require_config.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(require_utils.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 = require_config.isFieldIgnored(config, entity, fieldName, notNull, column.default !== null);
+	const isDeferredAndDeferrable = r.foreignKey.isDeferred && r.foreignKey.isDeferrable;
+	const derived = fkFieldDerived(config, entity, fieldName);
+	const hasConfigDefault = require_config.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];
+	const otherEntity = makeEntity(require_utils.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: require_config.isFieldIgnored(config, entity, fieldName) || require_config.isFieldIgnored(config, otherEntity, otherFieldName),
+		isLargeCollection: require_config.isLargeCollection(config, entity, fieldName),
+		orderBy: require_utils.parseOrder(orderBy),
+		softDeletes: require_config.softDeletesConfig(config, entity, fieldName)
+	};
+}
+function newOneToOne(config, entity, r) {
+	const column = r.foreignKey.columns[0];
+	const otherEntity = makeEntity(require_utils.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: require_config.isFieldIgnored(config, entity, fieldName) || require_config.isFieldIgnored(config, otherEntity, otherFieldName)
+	};
+}
+function newManyToManyField(config, entity, r) {
+	const { foreignKey, targetForeignKey, targetTable } = r;
+	const otherEntity = makeEntity(require_utils.tableToEntityName(config, targetTable));
+	const fieldName = manyToManyName(targetForeignKey.columns[0]);
+	const otherFieldName = manyToManyName(foreignKey.columns[0]);
+	const isDeferredAndDeferrable = targetForeignKey.isDeferred && targetForeignKey.isDeferrable;
+	const isThisSideDerived = require_config.isReactiveManyToMany(config, entity, fieldName);
+	const isOtherSideDerived = require_config.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: require_config.isFieldIgnored(config, entity, fieldName) || require_config.isFieldIgnored(config, otherEntity, otherFieldName),
+		isLargeCollection: require_config.isLargeCollection(config, entity, fieldName),
+		isDeferredAndDeferrable,
+		derived,
+		softDeletes: require_config.softDeletesConfig(config, entity, fieldName),
+		hasJoinTableId: require_utils.joinTableHasId(r.joinTable)
+	};
+}
+function newManyToManyEnumField(config, entity, r, enums) {
+	const { foreignKey, targetForeignKey, targetTable } = r;
+	const fieldName = manyToManyName(targetForeignKey.columns[0]);
+	const enumName = require_utils.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.imp)(`${enumName}@./entities.ts`),
+		enumDetailType: (0, ts_poet.imp)(`${plural(enumName)}@./entities.ts`),
+		enumDetailsType: (0, ts_poet.imp)(`${enumName}Details@./entities.ts`),
+		enumRows: enums[targetTable.name].rows,
+		ignore: require_config.isFieldIgnored(config, entity, fieldName),
+		hasJoinTableId: require_utils.joinTableHasId(r.joinTable)
+	};
+}
+function newPolymorphicField(config, table, entity, pr) {
+	const { fieldName, notNull } = pr;
+	const components = table.m2oRelations.filter((r) => !require_utils.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}${(0, change_case.pascalCase)(fieldName)}`,
+		notNull,
+		components,
+		hasConfigDefault: require_config.isFieldHasDefault(config, entity, fieldName)
+	};
+}
+function newPolymorphicFieldComponent(config, entity, r) {
+	const column = r.foreignKey.columns[0];
+	const columnName = column.name;
+	const otherEntity = makeEntity(require_utils.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");
+}
+/** Finds the field name for o2o side of a o2o/m2o. */
+function oneToOneName(config, refEntity, keyEntity, r) {
+	const overrides = r.foreignKey.columns[0].commentData;
+	if (isFieldNameOverrides(overrides) && overrides.otherFieldName) return overrides.otherFieldName;
+	if (!(r instanceof require_pgMetadata.M2ORelation ? r.targetTable : r.sourceTable).m2oRelations.find((s) => require_utils.tableToEntityName(config, s.targetTable) === keyEntity.name)) return (0, change_case.camelCase)(keyEntity.name);
+	else {
+		let fieldName = r.foreignKey.columns[0].name.replace(idSuffix, "");
+		fieldName = `${fieldName}_${keyEntity.name}`;
+		fieldName = fieldName.replace(refEntity.name.toLowerCase(), "");
+		return (0, change_case.camelCase)(fieldName);
+	}
+}
+const idSuffix = /_id$|Id$/;
+function referenceName(config, entity, r) {
+	const [column] = r.foreignKey.columns;
+	const overrides = column.commentData;
+	return polymorphicFieldName(config, r) ?? (isFieldNameOverrides(overrides) ? overrides.fieldName : void 0) ?? (0, change_case.camelCase)(column.name.replace(idSuffix, ""));
+}
+function enumFieldName(columnName) {
+	return (0, change_case.camelCase)(columnName.replace(idSuffix, ""));
+}
+function primitiveFieldName(columnName) {
+	return (0, change_case.camelCase)(columnName);
+}
+function manyToManyName(column) {
+	const overrides = column.commentData;
+	if (isFieldNameOverrides(overrides) && overrides.otherFieldName) return overrides.otherFieldName;
+	return (0, change_case.camelCase)(plural(column.name.replace(idSuffix, "")));
+}
+/** Returns the collection name to use on `entity` when referring to `otherEntity`s. */
+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 = (0, change_case.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.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) {
+	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.imp)(`${(0, change_case.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.
+*/
+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);
+		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).
+*/
+function resolveNameConflicts(config, db) {
+	const reserved = new Set(db.entities.map((meta) => meta.name));
+	for (const enumData of Object.values(db.enums)) {
+		const enumName = require_utils.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")
+	};
+}
+/** 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));
+}
+/** 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);
+}
+function entityTypeImport(entityName, symbolName) {
+	return (0, ts_poet.imp)(`t:${symbolName}@./entities.ts`, { definedIn: `./codegen/${entityName}Codegen.ts` });
+}
+function metaName(entityName) {
+	return `${(0, change_case.camelCase)(entityName)}Meta`;
+}
+function metaType(entityName) {
+	return (0, ts_poet.imp)(`${metaName(entityName)}@./entities.ts`);
+}
+function entityType(entityName) {
+	return (0, ts_poet.imp)(`t:${entityName}@./entities.ts`);
+}
+function entityTypeSymbol(entityName) {
+	return (0, ts_poet.imp)(`${entityName}@./entities.ts`);
+}
+function entityTypeForMetadataFile(entityName) {
+	return (0, ts_poet.imp)(`${entityName}@./${entityName}.ts`);
+}
+function mapType(config, tableName, columnName, dbColumnType) {
+	return require_utils.mapSimpleDbTypeToTypescriptType(config, dbColumnType);
+}
+function isEnumArray(c) {
+	return c.arrayDimension === 1 && !!c.comment && c.comment.startsWith("enum=");
+}
+function isArray(c) {
+	return c.arrayDimension === 1;
+}
+function isPgEnum(c) {
+	return c.type instanceof require_pgMetadata.EnumType;
+}
+function superstructType(s) {
+	const [symbol, ...path] = s.split("@");
+	return ts_poet.Import.from(`${(0, change_case.pascalCase)(symbol)}@${path.join("@")}`);
+}
+function zodSchemaType(s) {
+	const schema = ts_poet.Import.from(s);
+	return ts_poet.code`${require_symbols.Zod}.input<typeof ${schema}>`;
+}
+function userFieldTypeType(s) {
+	return ts_poet.Import.from(`t:${s}`);
+}
+function serdeType(s) {
+	return ts_poet.Import.from(s);
+}
+//#endregion
+exports.EntityDbMetadata = EntityDbMetadata;
+exports.canonicalizeOtherEntities = canonicalizeOtherEntities;
+exports.collectionName = collectionName;
+exports.failIfOverlappingFieldNames = failIfOverlappingFieldNames;
+exports.makeEntity = makeEntity;
+exports.manyToManyName = manyToManyName;
+exports.oneToOneName = oneToOneName;
+exports.referenceName = referenceName;
+exports.resolveNameConflicts = resolveNameConflicts;
+
+//# sourceMappingURL=EntityDbMetadata.cjs.map