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

package/build/generateEntityCodegenFile.cjs

@@ -0,0 +1,1010 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_utils = require("./utils.cjs");
+const require_inheritance = require("./inheritance.cjs");
+require("./config.cjs");
+const require_docs_parsing = require("./docs/parsing.cjs");
+require("./docs/index.cjs");
+require("./findEntityScopes.cjs");
+const require_keywords = require("./keywords.cjs");
+const require_symbols = require("./symbols.cjs");
+const require_tsdoc = require("./tsdoc.cjs");
+require("./EntityDbMetadata.cjs");
+let change_case = require("change-case");
+let pluralize = require("pluralize");
+pluralize = require_runtime.__toESM(pluralize, 1);
+let ts_poet = require("ts-poet");
+//#region src/generateEntityCodegenFile.ts
+const { plural } = pluralize.default;
+/** Creates the base class with the boilerplate annotations. */
+function generateEntityCodegenFile(config, dbMeta, meta, scopeMembers = [], docs) {
+	const { entitiesByName: metasByName } = dbMeta;
+	const { entity, tagName } = meta;
+	const entityName = entity.name;
+	const fieldDocs = docs?.fields ?? {};
+	const varName = require_keywords.keywords.includes(tagName) ? require_utils.uncapitalize(entityName) : tagName;
+	const primitives = createPrimitives(meta, entity, fieldDocs);
+	primitives.push(...createRegularEnums(meta, entity, fieldDocs));
+	primitives.push(...createArrayEnums(meta, fieldDocs));
+	primitives.push(...createPgEnums(meta, fieldDocs));
+	const relations = createRelations(config, meta, entity);
+	const configName = `${(0, change_case.camelCase)(entityName)}Config`;
+	const scopeFnName = `${(0, change_case.camelCase)(entityName)}Scope`;
+	const metadata = (0, ts_poet.imp)(`${(0, change_case.camelCase)(entityName)}Meta@./entities.ts`);
+	const contextType = config.contextType ? (0, ts_poet.imp)(`t:${config.contextType}`) : "{}";
+	const factoryMethod = (0, ts_poet.imp)(`new${entity.name}@./entities.ts`);
+	const idMaybeCode = config.idType === "tagged-string" ? ts_poet.code`return this.idTaggedMaybe;` : ts_poet.code`return ${require_symbols.toIdOf}(${metadata}, this.idTaggedMaybe);`;
+	const idType = getIdType(config);
+	const maybeSoftDeleteMethods = meta.deletedAt ? ts_poet.code`
+    get isSoftDeletedEntity(): boolean {
+      return this.${meta.deletedAt.fieldName} !== undefined;
+    }
+
+    softDelete(): void {
+      if (this.isSoftDeletedEntity) return;
+      this.${meta.deletedAt.fieldName} = ${nowUTCCall(config, meta.deletedAt)};
+    }
+  ` : "";
+	const baseEntity = dbMeta.entities.find((e) => e.name === meta.baseClassName);
+	const subEntities = dbMeta.entities.filter((e) => e.baseClassName === meta.name);
+	const base = baseEntity?.entity.typeSymbol ?? ts_poet.code`${require_symbols.BaseEntity}<${require_symbols.EntityManager}, ${idType}>`;
+	const maybeBaseFields = baseEntity ? ts_poet.code`extends Omit<${(0, ts_poet.imp)("t:" + baseEntity.entity.fieldsName + "@./entities.ts")}, "id"${[
+		...meta.primitives,
+		...meta.enums,
+		...meta.pgEnums,
+		...meta.manyToOnes
+	].filter((field) => [
+		...baseEntity.primitives,
+		...baseEntity.enums,
+		...baseEntity.pgEnums,
+		...baseEntity.manyToOnes
+	].some((baseField) => baseField.fieldName === field.fieldName)).map((field) => ts_poet.code` | "${field.fieldName}"`)}>` : "";
+	const maybeBaseOpts = baseEntity ? ts_poet.code`extends ${baseEntity.entity.optsType}` : "";
+	const physical = meta.physicalMetadata ?? meta;
+	const sharedTable = meta.inheritanceType === "sti" && baseEntity;
+	const columns = sharedTable ? {} : generateColumnsType(physical);
+	const maybeBaseColumns = sharedTable ? ts_poet.code`extends ${(0, ts_poet.imp)(`t:${baseEntity.name}Columns@./entities.ts`)}` : "";
+	const maybeBaseIdOpts = baseEntity ? ts_poet.code`extends ${(0, ts_poet.imp)("t:" + baseEntity.entity.idsOptsName + "@./entities.ts")}` : "";
+	const maybeBaseFilter = baseEntity ? ts_poet.code`extends ${(0, ts_poet.imp)("t:" + baseEntity.entity.filterName + "@./entities.ts")}` : "";
+	const maybeBaseGqlFilter = baseEntity ? ts_poet.code`extends ${(0, ts_poet.imp)("t:" + baseEntity.entity.graphqlFilterName + "@./entities.ts")}` : "";
+	const maybeBaseOrder = baseEntity ? ts_poet.code`extends ${baseEntity.entity.orderType}` : "";
+	meta.abstract && ts_poet.code`
+    if (this.constructor === ${entity.type} && !(em as any).fakeInstance) {
+      throw new Error(\`${entity.type} must be instantiated via a subtype\`);
+    }`;
+	let maybeOtherTypeChanges;
+	if (subEntities.length > 0) maybeOtherTypeChanges = (0, ts_poet.joinCode)([ts_poet.code`, `, ...[meta, ...subEntities].map((e) => ts_poet.code`keyof (${require_symbols.FieldsOf}<${e.entity.type}> & ${require_symbols.RelationsOf}<${e.entity.type}>)`)], { on: "|" });
+	else maybeOtherTypeChanges = "";
+	let maybeOtherLoaded;
+	if (baseEntity) maybeOtherLoaded = ts_poet.code`| ${baseEntity.entity.type}`;
+	else maybeOtherLoaded = "";
+	return ts_poet.code`
+    export type ${entity.idName} = ${require_symbols.Flavor}<${idType}, "${baseEntity ? baseEntity.name : entityName}">;
+
+    ${generatePolymorphicTypes(meta)}
+
+    export interface ${entity.fieldsName} ${maybeBaseFields} {
+      ${generateFieldsType(meta, idType)}
+    }
+
+    export interface ${entityName}Columns ${maybeBaseColumns} {
+      ${Object.entries(columns).map(([name, descriptor]) => ts_poet.code`${JSON.stringify(name)}: ${descriptor};`)}
+    }
+
+    export interface ${entity.optsName} ${maybeBaseOpts} {
+      ${generateOptsFields(meta)}
+    }
+
+    export interface ${entity.idsOptsName} ${maybeBaseIdOpts} {
+      ${generateOptIdsFields(meta)}
+    }
+
+    export interface ${entity.filterName} ${maybeBaseFilter} {
+      ${generateFilterFields(metasByName, meta)}
+    }
+
+    export interface ${entity.graphqlFilterName} ${maybeBaseGqlFilter} {
+      ${generateGraphQLFilterFields(metasByName, meta)}
+    }
+
+    export interface ${entity.orderName} ${maybeBaseOrder} {
+      ${generateOrderFields(meta)}
+    }
+
+    export interface ${entity.factoryExtrasName} {
+      ${generateFactoryExtrasType(meta)}
+    }
+
+    export interface ${entity.scopesName} {
+      ${scopeMembers.map((member) => ts_poet.code`${member.name}: ${member.type};`)}
+    }
+
+    export type ${entity.scopeName} = ${require_symbols.Scope}<${entity.type}, ${entity.scopesName}>;
+
+    export const ${configName} = new ${require_symbols.ConfigApi}<${entity.type}, ${contextType}>();
+
+    export const ${scopeFnName} = ${require_symbols.newScopeFn}<${entity.type}, ${entity.scopeName}>("${entityName}");
+
+    ${generateDefaultValidationRules(dbMeta, meta, configName)}
+    ${generateDefaultValues(config, meta, configName)};
+
+    declare module "joist-core" {
+      interface TypeMap {
+        ${entityName}: {
+          entityType: ${entityName};
+          filterType: ${entity.filterName};
+          gqlFilterType: ${entity.graphqlFilterName};
+          orderType: ${entity.orderName};
+          optsType: ${entity.optsName};
+          fieldsType: ${entity.fieldsName};
+          columnsType: ${entityName}Columns;
+          inheritanceType: ${meta.inheritanceType ? ts_poet.code`"${meta.inheritanceType}"` : "never"};
+          supportsEmExecute: ${!meta.inheritanceType && meta.supportsEmExecute === true};
+          optIdsType: ${entity.idsOptsName};
+          factoryExtrasType: ${entity.factoryExtrasName};
+          factoryOptsType: Parameters<typeof ${factoryMethod}>[1];
+        };
+      }
+    }
+
+    export abstract class ${entityName}Codegen extends ${base} implements ${require_symbols.ProjectEntity} {
+      static readonly tagName = "${tagName}";
+      static readonly metadata: ${require_symbols.EntityMetadata}<${entity.type}>;
+
+      declare readonly __type: {
+        ${baseEntity ? `0: "${baseEntity.name}",` : ""}
+        ${baseEntity ? 1 : 0}: "${entityName}", 
+      };
+
+      ${relations.filter((r) => r.kind === "abstract").map((r) => {
+		return ts_poet.code`${relationDocBlock(fieldDocs, r.fieldName, entityName)}${r.line}${maybeComment(r.comment)}`;
+	})}
+      ${relations.filter((r) => r.kind === "concrete").map((r) => {
+		return ts_poet.code`${relationDocBlock(fieldDocs, r.fieldName, entityName)}readonly ${r.fieldName}: ${r.decl} = ${r.init};${maybeComment(r.comment)}`;
+	})}
+      ${relations.filter((r) => r.kind === "super").map((r) => {
+		return ts_poet.code`${relationDocBlock(fieldDocs, r.fieldName, entityName)}declare readonly ${r.fieldName}: ${r.decl};${maybeComment(r.comment)}`;
+	})}
+
+      get id(): ${entity.idName} {
+        return this.idMaybe || ${require_symbols.failNoIdYet}("${entityName}");
+      }
+
+      get idMaybe(): ${entity.idName} | undefined {
+        ${idMaybeCode}
+      }
+
+      get idTagged(): ${require_symbols.TaggedId} {
+        return this.idTaggedMaybe || ${require_symbols.failNoIdYet}("${entityName}");
+      }
+
+      get idTaggedMaybe(): ${require_symbols.TaggedId} | undefined {
+        return ${require_symbols.getField}(this, "id");
+      }
+
+      ${primitives}    
+
+      ${require_tsdoc.tsdocComments.entity.setPartial}
+      set(opts: Partial<${entity.optsName}>): void {
+        ${require_symbols.setOpts}(this as any as ${entityName}, opts);
+      }
+
+      ${require_tsdoc.tsdocComments.entity.setPartial}
+      setPartial(opts: ${require_symbols.PartialOrNull}<${entity.optsName}>): void {
+        ${require_symbols.setOpts}(this as any as ${entityName}, opts as ${require_symbols.OptsOf}<${entityName}>, { partial: true });
+      }
+
+      ${require_tsdoc.tsdocComments.entity.setDeepPartial}
+      setDeepPartial(opts: ${require_symbols.DeepPartialOrNull}<${entityName}>): Promise<void> {
+        return ${require_symbols.updatePartial}(this as any as ${entityName}, opts);
+      }
+
+      ${require_tsdoc.tsdocComments.entity.changes}
+      get changes(): ${require_symbols.Changes}<${entityName}${maybeOtherTypeChanges}> {
+        return ${require_symbols.newChangesProxy}(this) as any;
+      }
+
+      ${maybeSoftDeleteMethods}
+
+      ${require_tsdoc.tsdocComments.entity.load}
+      load<U, V>(fn: (lens: ${require_symbols.Lens}<${entity.type}>) => ${require_symbols.Lens}<U, V>, opts: { sql?: boolean } = {}): Promise<V> {
+        return ${require_symbols.loadLens}(this as any as ${entityName}, fn, opts);
+      }
+
+      ${require_tsdoc.tsdocComments.entity.populate}
+      populate<const H extends ${require_symbols.LoadHint}<${entityName}>>(hint: H): Promise<${require_symbols.Loaded}<${entityName}, H>>;
+      populate<const H extends ${require_symbols.LoadHint}<${entityName}>>(opts: { hint: H, forceReload?: boolean }): Promise<${require_symbols.Loaded}<${entityName}, H>>;
+      populate<const H extends ${require_symbols.LoadHint}<${entityName}>, V>(hint: H, fn: (${varName}: Loaded<${entityName}, H>) => V): Promise<V>;
+      populate<const H extends ${require_symbols.LoadHint}<${entityName}>, V>(opts: { hint: H, forceReload?: boolean }, fn: (${varName}: Loaded<${entityName}, H>) => V): Promise<V>;
+      populate<const H extends ${require_symbols.LoadHint}<${entityName}>, V>(hintOrOpts: any, fn?: (${varName}: Loaded<${entityName}, H>) => V): Promise<${require_symbols.Loaded}<${entityName}, H> | V> {
+        return this.em.populate(this as any as ${entityName}, hintOrOpts, fn);
+      }
+
+      ${require_tsdoc.tsdocComments.entity.isLoaded}
+      isLoaded<const H extends ${require_symbols.LoadHint}<${entityName}>>(hint: H): this is ${require_symbols.Loaded}<${entityName}${maybeOtherLoaded}, H> {
+        return ${require_symbols.isLoaded}(this as any as ${entityName}, hint);
+      }
+
+      ${require_tsdoc.tsdocComments.entity.toJSON}
+      toJSON(): object;
+      toJSON<const H extends ${require_symbols.ToJsonHint}<${entityName}>>(hint: H): Promise<${require_symbols.JsonPayload}<${entityName}, H>>;
+      toJSON(hint?: any): object {
+        return !hint || typeof hint === "string" ? super.toJSON() : ${require_symbols.toJSON}(this, hint);
+      }
+    }
+  `;
+}
+function fieldHasDefaultValue(field) {
+	let { columnDefault } = field;
+	if (columnDefault === null) return false;
+	columnDefault = columnDefault.toString();
+	const fieldType = field.kind === "primitive" ? field.fieldType : "number";
+	return fieldType === "number" && !isNaN(parseInt(columnDefault)) || fieldType === "bigint" && !isNaN(parseInt(columnDefault)) || fieldType === "string" && /^'.*'$/.test(columnDefault) || fieldType === "boolean" && ["true", "false"].includes(columnDefault);
+}
+function generatePolymorphicTypes(meta) {
+	return meta.polymorphics.flatMap((pf) => [
+		ts_poet.code`export type ${pf.fieldType} = ${pf.components.map((c) => ts_poet.code`| ${c.otherEntity.type}`)};`,
+		ts_poet.code`export function get${pf.fieldType}Constructors(): ${require_symbols.MaybeAbstractEntityConstructor}<${pf.fieldType}>[] {
+      return [${pf.components.map((c) => ts_poet.code`${c.otherEntity.typeSymbol},`)}];
+    }`,
+		ts_poet.code`export function is${pf.fieldType}(maybeEntity: unknown): maybeEntity is ${pf.fieldType} {
+      return ${require_symbols.isEntity}(maybeEntity) && get${pf.fieldType}Constructors().some((type) => maybeEntity instanceof type);
+    }`
+	]);
+}
+function generateDefaultValues(config, meta, configName) {
+	function notSync(field) {
+		return "derived" in field && field.derived !== "sync";
+	}
+	const primitives = meta.primitives.filter((field) => fieldHasDefaultValue(field)).filter(notSync).map(({ fieldName, columnDefault }) => {
+		return ts_poet.code`${configName}.setDefault("${fieldName}", ${columnDefault});`;
+	});
+	const pgEnums = meta.pgEnums.filter((field) => !!field.columnDefault).map(({ fieldName, columnDefault }) => {
+		return ts_poet.code`${configName}.setDefault("${fieldName}", ${columnDefault});`;
+	});
+	const enums = meta.enums.filter((field) => !!field.columnDefault && !field.isArray).filter(notSync).map(({ fieldName, columnDefault, enumRows, enumType, columnName }) => {
+		const defaultRow = enumRows.find((r) => r.id === Number(columnDefault)) || require_utils.fail(`Invalid default value ${columnDefault} for ${meta.tableName}.${columnName}`);
+		return ts_poet.code`${configName}.setDefault("${fieldName}", ${enumType}.${(0, change_case.pascalCase)(defaultRow.code)});`;
+	});
+	return [
+		...primitives,
+		...enums,
+		...pgEnums
+	];
+}
+function generateDefaultValidationRules(db, meta, configName) {
+	const rules = [
+		...meta.primitives,
+		...meta.enums,
+		...meta.manyToOnes,
+		...meta.polymorphics
+	].filter((p) => p.notNull).map((p) => {
+		const { fieldName } = p;
+		const isReactive = "derived" in p && p.derived === "async";
+		if ("lazy" in p && p.lazy) return ts_poet.code`${configName}.addRule(${require_symbols.newRequiredLazyFieldRule}("${fieldName}"));`;
+		else if (isReactive) return ts_poet.code`${configName}.addRule("${fieldName}", ${require_symbols.newRequiredRule}("${fieldName}"));`;
+		else return ts_poet.code`${configName}.addRule(${require_symbols.newRequiredRule}("${fieldName}"));`;
+	});
+	if (meta.stiDiscriminatorField) {
+		const field = meta.enums.find((e) => e.fieldName === meta.stiDiscriminatorField) ?? require_utils.fail("STI field not found");
+		rules.push(ts_poet.code`${configName}.addRule(${require_symbols.cannotBeUpdated}("${field.fieldName}"));`);
+	}
+	const stiEntities = require_inheritance.getStiEntities(db.entities);
+	if (stiEntities.size > 0) for (const m2o of meta.manyToOnes) {
+		const target = stiEntities.get(m2o.otherEntity.name);
+		if (target && m2o.otherEntity.name !== target.base.name) rules.push(ts_poet.code`${configName}.addRule("${m2o.fieldName}", ${require_symbols.mustBeSubType}("${m2o.fieldName}"));`);
+	}
+	if (meta.baseType) meta.manyToOnes.filter((m2o) => meta.baseType?.manyToOnes?.find((o) => o.fieldName === m2o.fieldName && o.otherEntity.name !== m2o.otherEntity.name)).forEach((m2o) => {
+		rules.push(ts_poet.code`${configName}.addRule("${m2o.fieldName}", ${require_symbols.mustBeSubType}("${m2o.fieldName}"));`);
+	});
+	return rules;
+}
+function generateOptsFields(meta) {
+	const primitives = meta.primitives.map((field) => {
+		const { fieldName, fieldType, notNull, derived } = field;
+		if (derived) return ts_poet.code``;
+		return ts_poet.code`${fieldName}${maybeOptionalOrDefault(field)}: ${fieldType}${maybeUnionNull(notNull)};`;
+	});
+	const enums = meta.enums.map((field) => {
+		const { fieldName, enumType, notNull, isArray, derived } = field;
+		if (meta.stiDiscriminatorField === fieldName || derived) return ts_poet.code``;
+		else if (isArray) return ts_poet.code`${fieldName}?: ${enumType}[];`;
+		else return ts_poet.code`${fieldName}${maybeOptionalOrDefault(field)}: ${enumType}${maybeUnionNull(notNull)};`;
+	});
+	const pgEnums = meta.pgEnums.map((field) => {
+		const { fieldName, enumType, notNull } = field;
+		return ts_poet.code`${fieldName}${maybeOptionalOrDefault(field)}: ${enumType}${maybeUnionNull(notNull)};`;
+	});
+	const m2o = meta.manyToOnes.filter(({ derived }) => !derived).filter(({ fieldName }) => !meta.baseType?.manyToOnes.find((o) => o.fieldName === fieldName)).map((field) => {
+		const { fieldName, otherEntity, notNull } = field;
+		const maybeNull = maybeUnionNull(notNull);
+		return ts_poet.code`${fieldName}${maybeOptionalOrDefault(field)}: ${otherEntity.type} | ${otherEntity.idType} ${maybeNull};`;
+	});
+	const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}?: ${otherEntity.type} | null;`;
+	});
+	const o2m = meta.oneToManys.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}?: ${otherEntity.type}[];`;
+	});
+	const m2m = meta.manyToManys.filter(({ derived }) => !derived).map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}?: ${otherEntity.type}[];`;
+	});
+	const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
+		return ts_poet.code`${fieldName}?: ${enumType}[];`;
+	});
+	const polys = meta.polymorphics.map((field) => {
+		const { fieldName, notNull, fieldType } = field;
+		return ts_poet.code`${fieldName}${maybeOptionalOrDefault(field)}: ${fieldType};`;
+	});
+	return [
+		...primitives,
+		...enums,
+		...pgEnums,
+		...m2o,
+		...polys,
+		...o2o,
+		...o2m,
+		...m2m,
+		...m2mEnum
+	];
+}
+function generateFieldsType(meta, idType) {
+	const id = ts_poet.code`id: { kind: "primitive"; type: ${idType}; unique: ${true}; nullable: never; };`;
+	const primitives = meta.primitives.map((field) => {
+		const { fieldName, fieldType, notNull, unique, derived } = field;
+		return ts_poet.code`${fieldName}: { kind: "primitive"; type: ${fieldType}; unique: ${unique}; nullable: ${undefinedOrNever(notNull)}, derived: ${derived !== false}; };`;
+	});
+	const enums = meta.enums.map((field) => {
+		const { fieldName, enumType, notNull, isArray } = field;
+		if (isArray) return ts_poet.code`${fieldName}: { kind: "enum"; type: ${enumType}[]; nullable: never; };`;
+		else return ts_poet.code`${fieldName}: { kind: "enum"; type: ${enumType}; nullable: ${undefinedOrNever(notNull)}; };`;
+	});
+	const pgEnums = meta.pgEnums.map((field) => {
+		const { fieldName, enumType, notNull } = field;
+		const nullable = undefinedOrNever(notNull);
+		return ts_poet.code`${fieldName}: { kind: "enum"; type: ${enumType}; nullable: ${nullable}; native: true; };`;
+	});
+	const m2o = meta.manyToOnes.map((field) => {
+		const { fieldName, otherEntity, notNull, derived } = field;
+		return ts_poet.code`${fieldName}: { kind: "m2o"; type: ${otherEntity.type}; nullable: ${undefinedOrNever(notNull)}, derived: ${derived !== false}; };`;
+	});
+	const polys = meta.polymorphics.map((field) => {
+		const { fieldName, notNull, fieldType } = field;
+		return ts_poet.code`${fieldName}: { kind: "poly"; type: ${fieldType}; nullable: ${undefinedOrNever(notNull)} };`;
+	});
+	const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}: { kind: "m2m"; type: ${otherEntity.type} };`;
+	});
+	const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
+		return ts_poet.code`${fieldName}: { kind: "m2mEnum"; type: ${enumType} };`;
+	});
+	const o2m = meta.oneToManys.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}: { kind: "o2m"; type: ${otherEntity.type} };`;
+	});
+	const o2o = meta.oneToOnes.map((field) => {
+		return ts_poet.code`${field.fieldName}: { kind: "o2o"; type: ${field.otherEntity.type} };`;
+	});
+	const lo2m = meta.largeOneToManys.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}: { kind: "o2m"; type: ${otherEntity.type} };`;
+	});
+	return [
+		id,
+		...primitives,
+		...enums,
+		...pgEnums,
+		...m2o,
+		...polys,
+		...m2m,
+		...m2mEnum,
+		...o2m,
+		...o2o,
+		...lo2m
+	];
+}
+/**
+* Emits physical columns with domain value types and database nullability.
+* I.e. Comment.parent_book_id is an optional Book reference, not the CommentParent union.
+* fieldName identifies direct local domain filters; polymorphic components have no eligible name.
+* Polymorphic component writes remain unsupported, so their policies are conservative.
+*/
+function generateColumnsType(meta) {
+	const columns = { id: ts_poet.code`{ fieldName: "id"; type: ${require_symbols.IdOf}<${meta.entity.type}>; entity: ${meta.entity.type}; ${columnPolicyType(meta, meta.primaryKey)} }` };
+	for (const field of [
+		...meta.primitives,
+		...meta.enums,
+		...meta.pgEnums,
+		...meta.manyToOnes
+	]) {
+		const policy = ts_poet.code`fieldName: "${field.fieldName}"; ${columnPolicyType(meta, field)}`;
+		if (field.kind === "primitive") columns[field.columnName] = ts_poet.code`{ type: ${field.fieldType}; ${policy} }`;
+		else if (field.kind === "m2o") columns[field.columnName] = ts_poet.code`{ type: ${require_symbols.IdOf}<${field.otherEntity.type}>; entity: ${field.otherEntity.type}; ${policy} }`;
+		else {
+			const array = field.kind === "enum" && field.isArray ? "[]" : "";
+			columns[field.columnName] = ts_poet.code`{ type: ${field.enumType}${array}; ${policy} }`;
+		}
+	}
+	for (const field of meta.polymorphics) for (const component of field.components) columns[component.columnName] = ts_poet.code`{ fieldName: never; type: ${require_symbols.IdOf}<${component.otherEntity.type}>; entity: ${component.otherEntity.type}; nullable: true; insert: "never"; update: false; }`;
+	return columns;
+}
+/** Emits SQL write policy without using ORM defaults or derived-field restrictions. */
+function columnPolicyType(meta, column) {
+	const primaryKey = column === meta.primaryKey ? meta.primaryKey.columnType : void 0;
+	const insert = column.columnGenerated ? "never" : !column.columnNotNull || column.columnDefault != null || column === meta.createdAt || column === meta.updatedAt || primaryKey === "int" || primaryKey === "bigint" ? "optional" : "required";
+	return ts_poet.code`nullable: ${!column.columnNotNull}; insert: "${insert}"; update: ${!primaryKey && !column.columnGenerated};`;
+}
+function generateOptIdsFields(meta) {
+	const m2o = meta.manyToOnes.filter(({ derived }) => !derived).map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}Id?: ${otherEntity.idType} | null;`;
+	});
+	const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}Id?: ${otherEntity.idType} | null;`;
+	});
+	const o2m = meta.oneToManys.map(({ singularName, otherEntity }) => {
+		return ts_poet.code`${singularName}Ids?: ${otherEntity.idType}[] | null;`;
+	});
+	const m2m = meta.manyToManys.filter(({ derived }) => !derived).map(({ singularName, otherEntity }) => {
+		return ts_poet.code`${singularName}Ids?: ${otherEntity.idType}[] | null;`;
+	});
+	const polys = meta.polymorphics.map(({ fieldName, fieldType }) => {
+		return ts_poet.code`${fieldName}Id?:  ${require_symbols.IdOf}<${fieldType}> | null;`;
+	});
+	return [
+		...m2o,
+		...polys,
+		...o2o,
+		...o2m,
+		...m2m
+	];
+}
+function generateFilterFields(metasByName, meta) {
+	const maybeId = meta.baseClassName ? [] : [ts_poet.code`id?: ${require_symbols.ValueFilter}<${meta.entity.idName}, never> | null;`];
+	const primitives = meta.primitives.map(({ fieldName, fieldType, notNull }) => {
+		if (fieldType === "boolean") return ts_poet.code`${fieldName}?: ${require_symbols.BooleanFilter}<${nullOrNever(notNull)}>;`;
+		else return ts_poet.code`${fieldName}?: ${require_symbols.ValueFilter}<${fieldType}, ${nullOrNever(notNull)}>;`;
+	});
+	const enums = meta.enums.map(({ fieldName, enumType, notNull, isArray }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.ValueFilter}<${enumType}${isArray ? "[]" : ""}, ${nullOrNever(notNull)}>;`;
+	});
+	const pgEnums = meta.pgEnums.map(({ fieldName, enumType, notNull }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.ValueFilter}<${enumType}, ${nullOrNever(notNull)}>;`;
+	});
+	const m2o = meta.manyToOnes.flatMap(({ fieldName, otherEntity, notNull }) => {
+		const otherMeta = metasByName[otherEntity.name] ?? require_utils.fail(`Could not find metadata for ${otherEntity.name}`);
+		return [ts_poet.code`${fieldName}?: ${require_symbols.EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${require_symbols.FilterOf}<${otherEntity.type}>, ${nullOrNever(notNull)}>;`, ...otherMeta.subTypes.map((st) => {
+			return ts_poet.code`${fieldName}${st.name}?: ${require_symbols.EntityFilter}<${st.entity.type}, ${st.entity.idType}, ${require_symbols.FilterOf}<${st.entity.type}>, ${nullOrNever(notNull)}>;`;
+		})];
+	});
+	const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${require_symbols.FilterOf}<${otherEntity.type}>, null | undefined>;`;
+	});
+	const o2m = meta.oneToManys.flatMap(({ fieldName, otherEntity, otherColumnNotNull }) => {
+		const otherMeta = metasByName[otherEntity.name] ?? require_utils.fail(`Could not find metadata for ${otherEntity.name}`);
+		return [ts_poet.code`${fieldName}?: ${require_symbols.EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${require_symbols.FilterOf}<${otherEntity.type}>, null | undefined>;`, ...otherMeta.subTypes.map((st) => {
+			return ts_poet.code`${fieldName}${st.name}?: ${require_symbols.EntityFilter}<${st.entity.type}, ${st.entity.idType}, ${require_symbols.FilterOf}<${st.entity.type}>, ${nullOrNever(otherColumnNotNull)}>;`;
+		})];
+	});
+	const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${require_symbols.FilterOf}<${otherEntity.type}>, null | undefined>;`;
+	});
+	const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.ValueFilter}<${enumType}, null | undefined>;`;
+	});
+	const polys = meta.polymorphics.flatMap(({ fieldName, fieldType, components, notNull }) => {
+		return [ts_poet.code`${fieldName}?: ${require_symbols.EntityFilter}<${fieldType}, ${require_symbols.IdOf}<${fieldType}>, never, ${nullOrNever(notNull)}>;`, ...components.map((comp) => {
+			const { type } = comp.otherEntity;
+			return ts_poet.code`${fieldName}${type}?: ${require_symbols.EntityFilter}<${type}, ${require_symbols.IdOf}<${type}>, ${require_symbols.FilterOf}<${type}>, null>;`;
+		})];
+	});
+	return [
+		...maybeId,
+		...primitives,
+		...enums,
+		...pgEnums,
+		...m2o,
+		...o2o,
+		...o2m,
+		...m2m,
+		...m2mEnum,
+		...polys
+	];
+}
+function generateGraphQLFilterFields(metasByName, meta) {
+	const maybeId = meta.baseClassName ? [] : [ts_poet.code`id?: ${require_symbols.ValueGraphQLFilter}<${meta.entity.idName}>;`];
+	const primitives = meta.primitives.map(({ fieldName, fieldType }) => {
+		if (fieldType === "boolean") return ts_poet.code`${fieldName}?: ${require_symbols.BooleanGraphQLFilter};`;
+		else return ts_poet.code`${fieldName}?: ${require_symbols.ValueGraphQLFilter}<${fieldType}>;`;
+	});
+	const enums = meta.enums.map(({ fieldName, enumType, isArray }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.ValueGraphQLFilter}<${enumType}${isArray ? "[]" : ""}>;`;
+	});
+	const pgEnums = meta.pgEnums.map(({ fieldName, enumType }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.ValueGraphQLFilter}<${enumType}>;`;
+	});
+	const m2o = meta.manyToOnes.flatMap(({ fieldName, otherEntity, notNull }) => {
+		const otherMeta = metasByName[otherEntity.name];
+		return [
+			ts_poet.code`${fieldName}?: ${require_symbols.EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${require_symbols.GraphQLFilterOf}<${otherEntity.type}>, ${nullOrNever(notNull)}>;`,
+			ts_poet.code`${fieldName}Id?: ${require_symbols.ValueGraphQLFilter}<${otherEntity.idType}>;`,
+			...otherMeta.subTypes.map((st) => {
+				return ts_poet.code`${fieldName}${st.name}?: ${require_symbols.EntityGraphQLFilter}<${st.entity.type}, ${st.entity.idType}, ${require_symbols.GraphQLFilterOf}<${st.entity.type}>, ${nullOrNever(notNull)}>;`;
+			})
+		];
+	});
+	const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${require_symbols.GraphQLFilterOf}<${otherEntity.type}>, null | undefined>;`;
+	});
+	const o2m = meta.oneToManys.flatMap(({ fieldName, otherEntity, otherColumnNotNull }) => {
+		const otherMeta = metasByName[otherEntity.name] ?? require_utils.fail(`Could not find metadata for ${otherEntity.name}`);
+		return [ts_poet.code`${fieldName}?: ${require_symbols.EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${require_symbols.GraphQLFilterOf}<${otherEntity.type}>, null | undefined>;`, ...otherMeta.subTypes.map((st) => {
+			return ts_poet.code`${fieldName}${st.name}?: ${require_symbols.EntityGraphQLFilter}<${st.entity.type}, ${st.entity.idType}, ${require_symbols.GraphQLFilterOf}<${st.entity.type}>, ${nullOrNever(otherColumnNotNull)}>;`;
+		})];
+	});
+	const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${require_symbols.GraphQLFilterOf}<${otherEntity.type}>, null | undefined>;`;
+	});
+	const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.ValueGraphQLFilter}<${enumType}>;`;
+	});
+	const polys = meta.polymorphics.flatMap(({ fieldName, fieldType, components, notNull }) => {
+		return [
+			ts_poet.code`${fieldName}?: ${require_symbols.EntityGraphQLFilter}<${fieldType}, ${require_symbols.IdOf}<${fieldType}>, never, ${nullOrNever(notNull)}>;`,
+			ts_poet.code`${fieldName}Id?: ${require_symbols.ValueGraphQLFilter}<${require_symbols.IdOf}<${fieldType}>>;`,
+			...components.map((comp) => {
+				const { type } = comp.otherEntity;
+				return ts_poet.code`${fieldName}${type}?: ${require_symbols.EntityGraphQLFilter}<${type}, ${require_symbols.IdOf}<${type}>, ${require_symbols.FilterOf}<${type}>, null>;`;
+			})
+		];
+	});
+	return [
+		...maybeId,
+		...primitives,
+		...enums,
+		...pgEnums,
+		...m2o,
+		...o2o,
+		...o2m,
+		...m2m,
+		...m2mEnum,
+		...polys
+	];
+}
+function generateOrderFields(meta) {
+	const maybeId = meta.baseClassName ? [] : [ts_poet.code`id?: ${require_symbols.OrderBy};`];
+	const primitives = meta.primitives.map(({ fieldName }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.OrderBy};`;
+	});
+	const enums = meta.enums.map(({ fieldName }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.OrderBy};`;
+	});
+	const pgEnums = meta.pgEnums.map(({ fieldName }) => {
+		return ts_poet.code`${fieldName}?: ${require_symbols.OrderBy};`;
+	});
+	const m2o = meta.manyToOnes.map(({ fieldName, otherEntity }) => {
+		return ts_poet.code`${fieldName}?: ${otherEntity.orderType};`;
+	});
+	return [
+		...maybeId,
+		...primitives,
+		...enums,
+		...pgEnums,
+		...m2o
+	];
+}
+function generateFactoryExtrasType(meta) {
+	function withName(fieldName) {
+		return `with${fieldName[0].toUpperCase() + fieldName.substring(1)}`;
+	}
+	const primitives = meta.primitives.filter((f) => f.derived === "async").map((field) => {
+		const { fieldName, fieldType, notNull } = field;
+		return ts_poet.code`${withName(fieldName)}?: ${fieldType}${maybeUnionNull(notNull)};`;
+	});
+	const enums = meta.enums.filter((f) => f.derived === "async").map((field) => {
+		const { fieldName, enumType, notNull, isArray } = field;
+		if (isArray) return ts_poet.code`${withName(fieldName)}?: ${enumType}[];`;
+		else return ts_poet.code`${withName(fieldName)}?: ${enumType}${maybeUnionNull(notNull)};`;
+	});
+	return [...primitives, ...enums];
+}
+function createPrimitives(meta, entity, fieldDocs) {
+	return meta.primitives.map((p) => {
+		const { fieldName, fieldType, notNull } = p;
+		const maybeOptional = notNull ? "" : " | undefined";
+		if (p.lazy) return ts_poet.code``;
+		let getter;
+		if (p.derived === "async") getter = ts_poet.code`
+        abstract readonly ${fieldName}: ${require_symbols.ReactiveField}<${entity.name}, ${p.fieldType}${maybeOptional}>;
+     `;
+		else if (p.derived === "sync") getter = ts_poet.code`
+        abstract get ${fieldName}(): ${fieldType}${maybeOptional};
+     `;
+		else if (p.zodSchema) getter = ts_poet.code`
+        get ${fieldName}(): ${require_symbols.Zod}.output<typeof ${p.zodSchema}>${maybeOptional} {
+          return ${require_symbols.getField}(this, "${fieldName}");
+        }
+     `;
+		else getter = ts_poet.code`
+        get ${fieldName}(): ${fieldType}${maybeOptional} {
+          return ${require_symbols.getField}(this, "${fieldName}");
+        }
+     `;
+		let setter;
+		const paramName = require_keywords.keywords.includes(fieldName) ? "value" : fieldName;
+		if (p.protected) setter = ts_poet.code`
+        protected set${(0, change_case.pascalCase)(fieldName)}(${paramName}: ${fieldType}${maybeOptional}) {
+          ${require_symbols.setField}(this, "${fieldName}", ${paramName});
+        }
+      `;
+		else if (p.derived) setter = "";
+		else if (p.superstruct) setter = ts_poet.code`
+        set ${fieldName}(value: ${fieldType}${maybeOptional}) {
+          if (value) {
+            ${require_symbols.SSAssert}(value, ${p.superstruct});
+          }
+          ${require_symbols.setField}(this, "${fieldName}", value);
+        }
+      `;
+		else if (p.zodSchema) setter = ts_poet.code`
+        set ${fieldName}(value: ${require_symbols.Zod}.input<typeof ${p.zodSchema}>${maybeOptional}) {
+          if (value) {
+            ${require_symbols.setField}(this, "${fieldName}", ${p.zodSchema}.parse(value));
+          } else {
+            ${require_symbols.setField}(this, "${fieldName}", value);
+          }
+        }
+      `;
+		else setter = ts_poet.code`
+        set ${fieldName}(${paramName}: ${fieldType}${maybeOptional}) {
+          ${require_symbols.setField}(this, "${fieldName}", ${paramName});
+        }
+      `;
+		return ts_poet.code`${fieldDocBlock(fieldDocs, fieldName, entity.name)}${getter} ${setter}`;
+	});
+}
+function createRegularEnums(meta, entity, fieldDocs) {
+	return meta.enums.filter((e) => !e.isArray).flatMap((e) => {
+		const { fieldName, enumType, enumDetailType, enumDetailsType, notNull, enumRows, derived } = e;
+		const maybeOptional = notNull ? "" : " | undefined";
+		const getByCode = ts_poet.code`${enumDetailType}.getByCode(this.${fieldName})`;
+		let getter;
+		if (derived === "async") getter = ts_poet.code`
+          abstract readonly ${fieldName}: ${require_symbols.ReactiveField}<${entity.name}, ${enumType}${maybeOptional}>;
+       `;
+		else if (derived === "sync") getter = ts_poet.code`
+          abstract get ${fieldName}(): ${enumType}${maybeOptional};
+       `;
+		else getter = ts_poet.code`
+          get ${fieldName}(): ${enumType}${maybeOptional} {
+            return ${require_symbols.getField}(this, "${fieldName}");
+          }
+
+          get ${fieldName}Details(): ${enumDetailsType}${maybeOptional} {
+            return ${notNull ? getByCode : ts_poet.code`this.${fieldName} ? ${getByCode} : undefined`};
+          }
+       `;
+		let setter;
+		if (derived) setter = ts_poet.code``;
+		else setter = ts_poet.code`
+          set ${fieldName}(${fieldName}: ${enumType}${maybeOptional}) {
+            ${require_symbols.setField}(this, "${fieldName}", ${fieldName});
+          }
+        `;
+		const codes = new Set(enumRows.map((r) => r.code));
+		const shouldPrefixAccessors = meta.enums.filter((other) => other !== e).some((other) => other.enumRows.some((r) => codes.has(r.code)));
+		const accessors = enumRows.map((row) => ts_poet.code`
+          get is${shouldPrefixAccessors ? (0, change_case.pascalCase)(fieldName) : ""}${(0, change_case.pascalCase)(row.code)}(): boolean {
+            return ${require_symbols.getField}(this, "${fieldName}") === ${enumType}.${(0, change_case.pascalCase)(row.code)};
+          }
+        `);
+		return [
+			ts_poet.code`${fieldDocBlock(fieldDocs, fieldName, entity.name)}${getter}`,
+			setter,
+			...accessors
+		];
+	});
+}
+function createArrayEnums(meta, fieldDocs) {
+	return meta.enums.filter((e) => e.isArray).flatMap((e) => {
+		const { fieldName, enumType, enumDetailType, enumDetailsType, enumRows } = e;
+		const getter = ts_poet.code`
+        get ${fieldName}(): ${enumType}[] {
+          return ${require_symbols.getField}(this, "${fieldName}") || [];
+        }
+
+        get ${fieldName}Details(): ${enumDetailsType}[] {
+          return this.${fieldName}.map(code => ${enumDetailType}.getByCode(code));
+        }
+     `;
+		const setter = ts_poet.code`
+        set ${fieldName}(${fieldName}: ${enumType}[]) {
+          ${require_symbols.setField}(this, "${fieldName}", ${fieldName});
+        }
+      `;
+		const codes = new Set(enumRows.map((r) => r.code));
+		const shouldPrefixAccessors = meta.enums.filter((other) => other !== e).some((other) => other.enumRows.some((r) => codes.has(r.code)));
+		const accessors = enumRows.map((row) => ts_poet.code`
+          get is${shouldPrefixAccessors ? (0, change_case.pascalCase)(fieldName) : ""}${(0, change_case.pascalCase)(row.code)}(): boolean {
+            return this.${fieldName}.includes(${enumType}.${(0, change_case.pascalCase)(row.code)});
+          }
+        `);
+		return [
+			ts_poet.code`${fieldDocBlock(fieldDocs, fieldName, meta.entity.name)}${getter}`,
+			setter,
+			...accessors
+		];
+	});
+}
+function createPgEnums(meta, fieldDocs) {
+	return meta.pgEnums.flatMap((e) => {
+		const { fieldName, enumType, enumValues, notNull } = e;
+		const maybeOptional = notNull ? "" : " | undefined";
+		const getter = ts_poet.code`
+        get ${fieldName}(): ${enumType}${maybeOptional} {
+          return ${require_symbols.getField}(this, "${fieldName}");
+        }
+     `;
+		const setter = ts_poet.code`
+        set ${fieldName}(${fieldName}: ${enumType}${maybeOptional}) {
+          ${require_symbols.setField}(this, "${fieldName}", ${fieldName});
+        }
+      `;
+		const codes = new Set(enumValues);
+		const shouldPrefixAccessors = meta.pgEnums.filter((other) => other !== e).some((other) => other.enumValues.some((r) => codes.has(r)));
+		const accessors = enumValues.map((row) => ts_poet.code`
+          get is${shouldPrefixAccessors ? (0, change_case.pascalCase)(fieldName) : ""}${(0, change_case.pascalCase)(row)}(): boolean {
+            return this.${fieldName} === ${enumType}.${(0, change_case.pascalCase)(row)};
+          }
+        `);
+		return [
+			ts_poet.code`${fieldDocBlock(fieldDocs, fieldName, meta.entity.name)}${getter}`,
+			setter,
+			...accessors
+		];
+	});
+}
+function createRelations(config, meta, entity) {
+	const m2o = meta.manyToOnes.map((m2o) => {
+		const { fieldName, otherEntity, otherFieldName, notNull } = m2o;
+		const maybeOptional = notNull ? "never" : "undefined";
+		if (m2o.derived === "async") return {
+			kind: "abstract",
+			fieldName,
+			line: ts_poet.code`abstract readonly ${fieldName}: ${require_symbols.ReactiveReference}<${entity.name}, ${otherEntity.type}, ${maybeOptional}>;`
+		};
+		return {
+			kind: "concrete",
+			fieldName,
+			decl: ts_poet.code`${require_symbols.ManyToOneReference}<${entity.type}, ${otherEntity.type}, ${maybeOptional}>`,
+			init: ts_poet.code`${require_symbols.hasOne}()`
+		};
+	});
+	const m2oBase = meta.baseType?.manyToOnes.filter((m2o) => !meta.manyToOnes.find((o) => o.fieldName === m2o.fieldName)).filter((m2o) => m2o.derived !== "async").map((m2o) => {
+		const { fieldName, otherEntity, notNull } = m2o;
+		const maybeOptional = notNull ? "never" : "undefined";
+		return {
+			kind: "super",
+			fieldName,
+			decl: ts_poet.code`${require_symbols.ManyToOneReference}<${entity.type}, ${otherEntity.type}, ${maybeOptional}>`
+		};
+	}) ?? [];
+	const m2oRecursive = meta.manyToOnes.filter((m2o) => m2o.otherEntity.name === meta.name).filter((m2o) => !(config.entities[meta.inheritanceType == "sti" && meta.baseClassName ? meta.baseClassName : meta.name]?.relations?.[m2o.fieldName]?.skipRecursiveRelations === true)).filter((m2o) => !m2o.derived).flatMap((m2o) => {
+		const { fieldName: m2oName, otherFieldName, otherEntity } = m2o;
+		const parentsField = `${plural(m2oName)}Recursive`;
+		const childrenField = meta.oneToOnes.find((o2o) => o2o.fieldName === otherFieldName) ? `${plural(otherFieldName)}Recursive` : `${otherFieldName}Recursive`;
+		return [{
+			kind: "concrete",
+			fieldName: parentsField,
+			decl: ts_poet.code`${require_symbols.ReadOnlyCollection}<${entity.type}, ${otherEntity.type}>`,
+			init: ts_poet.code`${require_symbols.hasRecursiveParents}("${m2oName}", "${childrenField}")`
+		}, {
+			kind: "concrete",
+			fieldName: childrenField,
+			decl: ts_poet.code`${require_symbols.ReadOnlyCollection}<${entity.type}, ${otherEntity.type}>`,
+			init: ts_poet.code`${require_symbols.hasRecursiveChildren}("${otherFieldName}", "${parentsField}")`
+		}];
+	});
+	const m2mRecursive = meta.manyToManys.filter((m2m) => m2m.otherEntity.name === meta.name).filter((m2m) => !m2m.derived).filter((m2m) => !(config.entities[meta.inheritanceType == "sti" && meta.baseClassName ? meta.baseClassName : meta.name]?.relations?.[m2m.fieldName]?.skipRecursiveRelations === true)).map((m2m) => {
+		const { fieldName, otherFieldName, otherEntity } = m2m;
+		return {
+			kind: "concrete",
+			fieldName: `${fieldName}Recursive`,
+			decl: ts_poet.code`${require_symbols.ReadOnlyCollection}<${entity.type}, ${otherEntity.type}>`,
+			init: ts_poet.code`${require_symbols.hasRecursiveM2m}("${fieldName}", "${otherFieldName}Recursive")`
+		};
+	});
+	return [
+		meta.oneToManys.map((o2m) => {
+			const { fieldName, otherEntity } = o2m;
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.Collection}<${entity.type}, ${otherEntity.type}>`,
+				init: ts_poet.code`${require_symbols.hasMany}()`
+			};
+		}),
+		meta.baseType?.oneToManys.filter((o2m) => !meta.oneToManys.find((o) => o.fieldName === o2m.fieldName)).map((o2m) => {
+			const { fieldName, otherEntity } = o2m;
+			return {
+				kind: "super",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.Collection}<${entity.type}, ${otherEntity.type}>`
+			};
+		}) ?? [],
+		meta.largeOneToManys.map((o2m) => {
+			const { fieldName, otherEntity } = o2m;
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.LargeCollection}<${entity.type}, ${otherEntity.type}>`,
+				init: ts_poet.code`${require_symbols.hasLargeMany}()`
+			};
+		}),
+		m2o,
+		m2oBase,
+		m2oRecursive,
+		m2mRecursive,
+		meta.oneToOnes.map((o2o) => {
+			const { fieldName, otherEntity } = o2o;
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.OneToOneReference}<${entity.type}, ${otherEntity.type}>`,
+				init: ts_poet.code`${require_symbols.hasOneToOne}()`
+			};
+		}),
+		meta.baseType?.oneToOnes.map((o2o) => {
+			const { fieldName, otherEntity } = o2o;
+			return {
+				kind: "super",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.OneToOneReference}<${entity.type}, ${otherEntity.type}>`
+			};
+		}) ?? [],
+		meta.manyToManys.map((m2m) => {
+			const { fieldName, otherEntity } = m2m;
+			const comment = `// ${m2m.joinTableName} ${m2m.columnName} ${m2m.otherColumnName}`;
+			if (m2m.derived === "async") return {
+				kind: "abstract",
+				fieldName,
+				line: ts_poet.code`abstract readonly ${fieldName}: ${require_symbols.ReactiveManyToMany}<${entity.name}, ${otherEntity.type}>;`,
+				comment
+			};
+			else if (m2m.derived === "otherSide") return {
+				kind: "concrete",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.ReactiveManyToManyOtherSide}<${entity.type}, ${otherEntity.type}>`,
+				init: ts_poet.code`${require_symbols.hasReactiveManyToManyOtherSide}()`,
+				comment
+			};
+			else if (!m2m.derived) return {
+				kind: "concrete",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.Collection}<${entity.type}, ${otherEntity.type}>`,
+				init: ts_poet.code`${require_symbols.hasManyToMany}()`,
+				comment
+			};
+			else require_utils.assertNever(m2m.derived);
+		}),
+		meta.baseType?.manyToManys.filter((m2m) => !m2m.derived).map((m2m) => {
+			const { fieldName, otherEntity } = m2m;
+			return {
+				kind: "super",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.Collection}<${entity.type}, ${otherEntity.type}>`
+			};
+		}) ?? [],
+		meta.manyToManyEnums.map((m2m) => {
+			const { fieldName, enumType } = m2m;
+			const comment = `// ${m2m.joinTableName} ${m2m.columnName} ${m2m.otherColumnName}`;
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.EnumCollection}<${entity.type}, ${enumType}>`,
+				init: ts_poet.code`${require_symbols.hasEnumCollection}()`,
+				comment
+			};
+		}),
+		meta.baseType?.manyToManyEnums.map((m2m) => {
+			const { fieldName, enumType } = m2m;
+			return {
+				kind: "super",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.EnumCollection}<${entity.type}, ${enumType}>`
+			};
+		}) ?? [],
+		meta.largeManyToManys.map((m2m) => {
+			const { joinTableName, fieldName, columnName, otherEntity, otherFieldName, otherColumnName } = m2m;
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.LargeCollection}<${entity.type}, ${otherEntity.type}>`,
+				init: ts_poet.code`
+      ${require_symbols.hasLargeManyToMany}(
+        "${joinTableName}",
+        "${columnName}",
+        "${otherFieldName}",
+        "${otherColumnName}",
+        ${m2m.hasJoinTableId},
+      );
+    `
+			};
+		}),
+		meta.polymorphics.map((p) => {
+			const { fieldName, notNull, fieldType } = p;
+			const maybeOptional = notNull ? "never" : "undefined";
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.PolymorphicReference}<${entity.type}, ${fieldType}, ${maybeOptional}>`,
+				init: ts_poet.code`${require_symbols.hasOnePolymorphic}()`
+			};
+		}),
+		meta.primitives.filter((p) => p.lazy).map((p) => {
+			const { fieldName, fieldType, notNull } = p;
+			const maybeOptional = notNull ? "" : " | undefined";
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: ts_poet.code`${require_symbols.LazyField}<${entity.type}, ${fieldType}${maybeOptional}>`,
+				init: ts_poet.code`${require_symbols.hasLazyField}()`
+			};
+		})
+	].flat();
+}
+/** Makes the field required if there is a `NOT NULL` and no db-or-config default. */
+function maybeOptionalOrDefault(field) {
+	const hasDefault = field.kind !== "m2o" && field.kind !== "poly" && fieldHasDefaultValue(field) || field.hasConfigDefault;
+	return !field.notNull || hasDefault ? "?" : "";
+}
+function maybeUnionNull(notNull) {
+	return notNull ? "" : " | null";
+}
+function undefinedOrNever(notNull) {
+	return notNull ? "never" : "undefined";
+}
+function nullOrNever(notNull) {
+	return notNull ? "never" : "null";
+}
+/** Returns the nowUTC call for the deleted-at field's generated timestamp type. */
+function nowUTCCall(config, field) {
+	if (!config.temporal) return ts_poet.code`${require_symbols.nowUTC}()`;
+	switch (field.columnType) {
+		case "date": return ts_poet.code`${require_symbols.nowUTC}("plainDate")`;
+		case "timestamp without time zone": return ts_poet.code`${require_symbols.nowUTC}("plainDateTime")`;
+		case "timestamp with time zone": return ts_poet.code`${require_symbols.nowUTC}("zonedDateTime")`;
+		default: return require_utils.fail(`Unsupported deleted-at column type ${field.columnType}`);
+	}
+}
+/** Prefixes the comment with a newline, so it gets its own line. */
+function maybeComment(comment) {
+	return comment ? ` ${comment}\n` : "";
+}
+/**
+* Renders a field's `.md` doc (plus its `@generated` tag) as a bare JSDoc block, or `""` if undocumented.
+*
+* Reuses the same {@link buildJSDocBlock} formatter the `.md` sync uses for hand-written `Entity.ts`
+* members. Used directly before a getter template (which supplies its own leading newline), so the
+* JSDoc lands immediately above the getter with no intervening blank line.
+*/
+function fieldDocBlock(fieldDocs, fieldName, entityName) {
+	const doc = fieldDocs[fieldName];
+	return doc ? require_docs_parsing.buildJSDocBlock(`${doc}\n${require_docs_parsing.generatedTag(entityName)}`, 0) : "";
+}
+/** Like {@link fieldDocBlock} but wrapped in newlines, i.e. for inline `readonly x = ...` relation decls. */
+function relationDocBlock(fieldDocs, fieldName, entityName) {
+	const block = fieldDocBlock(fieldDocs, fieldName, entityName);
+	return block ? `\n${block}\n` : "";
+}
+function getIdType(config) {
+	switch (config.idType) {
+		case "untagged-string":
+		case "tagged-string":
+		case void 0: return "string";
+		case "number": return "number";
+		default: return require_utils.assertNever(config.idType);
+	}
+}
+//#endregion
+exports.generateEntityCodegenFile = generateEntityCodegenFile;
+exports.getIdType = getIdType;
+
+//# sourceMappingURL=generateEntityCodegenFile.cjs.map