joist-codegen 2.3.0-next.7 → 2.3.0-next.71

package/build/generateEntityCodegenFile.js

@@ -1,99 +1,82 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateEntityCodegenFile = generateEntityCodegenFile;
-exports.getIdType = getIdType;
-const change_case_1 = require("change-case");
-const pluralize_1 = require("pluralize");
-const ts_poet_1 = require("ts-poet");
-const inheritance_1 = require("./inheritance");
-const keywords_1 = require("./keywords");
-const symbols_1 = require("./symbols");
-const tsdoc_1 = require("./tsdoc");
-const utils_1 = require("./utils");
+import { assertNever, fail, uncapitalize } from "./utils.js";
+import { getStiEntities } from "./inheritance.js";
+import "./config.js";
+import { buildJSDocBlock, generatedTag } from "./docs/parsing.js";
+import "./docs/index.js";
+import "./findEntityScopes.js";
+import { keywords } from "./keywords.js";
+import { BaseEntity, BooleanFilter, BooleanGraphQLFilter, Changes, Collection, ConfigApi, DeepPartialOrNull, EntityFilter, EntityGraphQLFilter, EntityManager, EntityMetadata, EnumCollection, FieldsOf, FilterOf, Flavor, GraphQLFilterOf, IdOf, JsonPayload, LargeCollection, LazyField, Lens, LoadHint, Loaded, ManyToOneReference, MaybeAbstractEntityConstructor, OneToOneReference, OptsOf, OrderBy, PartialOrNull, PolymorphicReference, ProjectEntity, ReactiveField, ReactiveManyToMany, ReactiveManyToManyOtherSide, ReactiveReference, ReadOnlyCollection, RelationsOf, SSAssert, Scope, TaggedId, ToJsonHint, ValueFilter, ValueGraphQLFilter, Zod, cannotBeUpdated, failNoIdYet, getField, hasEnumCollection, hasLargeMany, hasLargeManyToMany, hasLazyField, hasMany, hasManyToMany, hasOne, hasOnePolymorphic, hasOneToOne, hasReactiveManyToManyOtherSide, hasRecursiveChildren, hasRecursiveM2m, hasRecursiveParents, isEntity, isLoaded, loadLens, mustBeSubType, newChangesProxy, newRequiredLazyFieldRule, newRequiredRule, newScopeFn, nowUTC, setField, setOpts, toIdOf, toJSON, updatePartial } from "./symbols.js";
+import { tsdocComments } from "./tsdoc.js";
+import "./EntityDbMetadata.js";
+import { camelCase, pascalCase } from "change-case";
+import pluralize from "pluralize";
+import { code, imp, joinCode } from "ts-poet";
+//#region src/generateEntityCodegenFile.ts
+const { plural } = pluralize;
 /** Creates the base class with the boilerplate annotations. */
-function generateEntityCodegenFile(config, dbMeta, meta, scopeMembers = []) {
-    const { entitiesByName: metasByName } = dbMeta;
-    const { entity, tagName } = meta;
-    const entityName = entity.name;
-    // Avoid using `do` as a variable name b/c it's a reserved keyword
-    const varName = keywords_1.keywords.includes(tagName) ? (0, utils_1.uncapitalize)(entityName) : tagName;
-    const primitives = createPrimitives(meta, entity); // Add the primitives
-    primitives.push(...createRegularEnums(meta, entity)); // Add ManyToOne enums
-    primitives.push(...createArrayEnums(meta)); // Add integer[] enums
-    primitives.push(...createPgEnums(meta)); // Add native enums
-    const relations = createRelations(config, meta, entity);
-    const configName = `${(0, change_case_1.camelCase)(entityName)}Config`;
-    const scopeFnName = `${(0, change_case_1.camelCase)(entityName)}Scope`;
-    const metadata = (0, ts_poet_1.imp)(`${(0, change_case_1.camelCase)(entityName)}Meta@./entities.ts`);
-    const contextType = config.contextType ? (0, ts_poet_1.imp)(`t:${config.contextType}`) : "{}";
-    const factoryMethod = (0, ts_poet_1.imp)(`new${entity.name}@./entities.ts`);
-    // If we're not tagged-strings, detag on the way out of id
-    const idMaybeCode = config.idType === "tagged-string"
-        ? (0, ts_poet_1.code) `return this.idTaggedMaybe;`
-        : (0, ts_poet_1.code) `return ${symbols_1.toIdOf}(${metadata}, this.idTaggedMaybe);`;
-    const idType = getIdType(config);
-    const maybeIsSoftDeleted = meta.deletedAt
-        ? (0, ts_poet_1.code) `
+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 = keywords.includes(tagName) ? 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 = `${camelCase(entityName)}Config`;
+	const scopeFnName = `${camelCase(entityName)}Scope`;
+	const metadata = imp(`${camelCase(entityName)}Meta@./entities.ts`);
+	const contextType = config.contextType ? imp(`t:${config.contextType}`) : "{}";
+	const factoryMethod = imp(`new${entity.name}@./entities.ts`);
+	const idMaybeCode = config.idType === "tagged-string" ? code`return this.idTaggedMaybe;` : code`return ${toIdOf}(${metadata}, this.idTaggedMaybe);`;
+	const idType = getIdType(config);
+	const maybeSoftDeleteMethods = meta.deletedAt ? code`
     get isSoftDeletedEntity(): boolean {
       return this.${meta.deletedAt.fieldName} !== undefined;
     }
-  `
-        : "";
-    // Set up the codegen artifacts to extend from the base type if necessary
-    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 ?? (0, ts_poet_1.code) `${symbols_1.BaseEntity}<${symbols_1.EntityManager}, ${idType}>`;
-    const maybeBaseFields = baseEntity
-        ? (0, ts_poet_1.code) `extends ${(0, ts_poet_1.imp)("t:" + baseEntity.entity.fieldsName + "@./entities.ts")}`
-        : "";
-    const maybeBaseOpts = baseEntity ? (0, ts_poet_1.code) `extends ${baseEntity.entity.optsType}` : "";
-    const maybeBaseIdOpts = baseEntity
-        ? (0, ts_poet_1.code) `extends ${(0, ts_poet_1.imp)("t:" + baseEntity.entity.idsOptsName + "@./entities.ts")}`
-        : "";
-    const maybeBaseFilter = baseEntity
-        ? (0, ts_poet_1.code) `extends ${(0, ts_poet_1.imp)("t:" + baseEntity.entity.filterName + "@./entities.ts")}`
-        : "";
-    const maybeBaseGqlFilter = baseEntity
-        ? (0, ts_poet_1.code) `extends ${(0, ts_poet_1.imp)("t:" + baseEntity.entity.graphqlFilterName + "@./entities.ts")}`
-        : "";
-    const maybeBaseOrder = baseEntity ? (0, ts_poet_1.code) `extends ${baseEntity.entity.orderType}` : "";
-    const maybePreventBaseTypeInstantiation = meta.abstract
-        ? (0, ts_poet_1.code) `
+
+    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 ?? code`${BaseEntity}<${EntityManager}, ${idType}>`;
+	const maybeBaseFields = baseEntity ? code`extends Omit<${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) => code` | "${field.fieldName}"`)}>` : "";
+	const maybeBaseOpts = baseEntity ? code`extends ${baseEntity.entity.optsType}` : "";
+	const physical = meta.physicalMetadata ?? meta;
+	const sharedTable = meta.inheritanceType === "sti" && baseEntity;
+	const columns = sharedTable ? {} : generateColumnsType(physical);
+	const maybeBaseColumns = sharedTable ? code`extends ${imp(`t:${baseEntity.name}Columns@./entities.ts`)}` : "";
+	const maybeBaseIdOpts = baseEntity ? code`extends ${imp("t:" + baseEntity.entity.idsOptsName + "@./entities.ts")}` : "";
+	const maybeBaseFilter = baseEntity ? code`extends ${imp("t:" + baseEntity.entity.filterName + "@./entities.ts")}` : "";
+	const maybeBaseGqlFilter = baseEntity ? code`extends ${imp("t:" + baseEntity.entity.graphqlFilterName + "@./entities.ts")}` : "";
+	const maybeBaseOrder = baseEntity ? code`extends ${baseEntity.entity.orderType}` : "";
+	meta.abstract && 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_1.joinCode)(
-        // Pass `K = keyof Publisher | keyof SmallPublisher | keyof LargePublisher` to `changes` so that
-        // our subtypes can have `SmallPublisher.changes(): Changes<SmallPublisher>` be covariant, which
-        // will break if it adds a key to `Changes.fields` that `Publisher.changes()` does not include.
-        //
-        // type A1 = { foo: 1 | 2 };
-        // type A2 = { foo: 1 | 2 | 3 };
-        // type A3 = A2 extends A1 ? 1 : 2;
-        //
-        // A3 will be 2 because the extra 3 breaks code written against A1.foo.
-        //
-        // So essentially we're pre-emptively our subtypes "3".
-        [
-            (0, ts_poet_1.code) `, `,
-            ...[meta, ...subEntities].map((e) => (0, ts_poet_1.code) `keyof (${symbols_1.FieldsOf}<${e.entity.type}> & ${symbols_1.RelationsOf}<${e.entity.type}>)`),
-        ], { on: "|" });
-    }
-    else {
-        maybeOtherTypeChanges = "";
-    }
-    let maybeOtherLoaded;
-    if (baseEntity) {
-        maybeOtherLoaded = (0, ts_poet_1.code) `| ${baseEntity.entity.type}`;
-    }
-    else {
-        maybeOtherLoaded = "";
-    }
-    return (0, ts_poet_1.code) `
-    export type ${entity.idName} = ${symbols_1.Flavor}<${idType}, "${baseEntity ? baseEntity.name : entityName}">;
+    }`;
+	let maybeOtherTypeChanges;
+	if (subEntities.length > 0) maybeOtherTypeChanges = joinCode([code`, `, ...[meta, ...subEntities].map((e) => code`keyof (${FieldsOf}<${e.entity.type}> & ${RelationsOf}<${e.entity.type}>)`)], { on: "|" });
+	else maybeOtherTypeChanges = "";
+	let maybeOtherLoaded;
+	if (baseEntity) maybeOtherLoaded = code`| ${baseEntity.entity.type}`;
+	else maybeOtherLoaded = "";
+	return code`
+    export type ${entity.idName} = ${Flavor}<${idType}, "${baseEntity ? baseEntity.name : entityName}">;
 
     ${generatePolymorphicTypes(meta)}
 
@@ -101,6 +84,10 @@ function generateEntityCodegenFile(config, dbMeta, meta, scopeMembers = []) {
       ${generateFieldsType(meta, idType)}
     }
 
+    export interface ${entityName}Columns ${maybeBaseColumns} {
+      ${Object.entries(columns).map(([name, descriptor]) => code`${JSON.stringify(name)}: ${descriptor};`)}
+    }
+
     export interface ${entity.optsName} ${maybeBaseOpts} {
       ${generateOptsFields(meta)}
     }
@@ -126,14 +113,14 @@ function generateEntityCodegenFile(config, dbMeta, meta, scopeMembers = []) {
     }
 
     export interface ${entity.scopesName} {
-      ${scopeMembers.map((member) => (0, ts_poet_1.code) `${member.name}: ${member.type};`)}
+      ${scopeMembers.map((member) => code`${member.name}: ${member.type};`)}
     }
 
-    export type ${entity.scopeName} = ${symbols_1.Scope}<${entity.type}, ${entity.scopesName}>;
+    export type ${entity.scopeName} = ${Scope}<${entity.type}, ${entity.scopesName}>;
 
-    export const ${configName} = new ${symbols_1.ConfigApi}<${entity.type}, ${contextType}>();
+    export const ${configName} = new ${ConfigApi}<${entity.type}, ${contextType}>();
 
-    export const ${scopeFnName} = ${symbols_1.newScopeFn}<${entity.type}, ${entity.scopeName}>("${entityName}");
+    export const ${scopeFnName} = ${newScopeFn}<${entity.type}, ${entity.scopeName}>("${entityName}");
 
     ${generateDefaultValidationRules(dbMeta, meta, configName)}
     ${generateDefaultValues(config, meta, configName)};
@@ -147,6 +134,9 @@ function generateEntityCodegenFile(config, dbMeta, meta, scopeMembers = []) {
           orderType: ${entity.orderName};
           optsType: ${entity.optsName};
           fieldsType: ${entity.fieldsName};
+          columnsType: ${entityName}Columns;
+          inheritanceType: ${meta.inheritanceType ? code`"${meta.inheritanceType}"` : "never"};
+          supportsEmExecute: ${!meta.inheritanceType && meta.supportsEmExecute === true};
           optIdsType: ${entity.idsOptsName};
           factoryExtrasType: ${entity.factoryExtrasName};
           factoryOptsType: Parameters<typeof ${factoryMethod}>[1];
@@ -154,887 +144,862 @@ function generateEntityCodegenFile(config, dbMeta, meta, scopeMembers = []) {
       }
     }
 
-    export abstract class ${entityName}Codegen extends ${base} implements ${symbols_1.ProjectEntity} {
+    export abstract class ${entityName}Codegen extends ${base} implements ${ProjectEntity} {
       static readonly tagName = "${tagName}";
-      static readonly metadata: ${symbols_1.EntityMetadata}<${entity.type}>;
+      static readonly metadata: ${EntityMetadata}<${entity.type}>;
 
       declare readonly __type: {
         ${baseEntity ? `0: "${baseEntity.name}",` : ""}
         ${baseEntity ? 1 : 0}: "${entityName}", 
       };
 
-      ${relations
-        .filter((r) => r.kind === "abstract")
-        .map((r) => {
-        return (0, ts_poet_1.code) `${r.line}${maybeComment(r.comment)}`;
-    })}
-      ${relations
-        .filter((r) => r.kind === "concrete")
-        .map((r) => {
-        return (0, ts_poet_1.code) `readonly ${r.fieldName}: ${r.decl} = ${r.init};${maybeComment(r.comment)}`;
-    })}
-      ${relations
-        .filter((r) => r.kind === "super")
-        .map((r) => {
-        return (0, ts_poet_1.code) `declare readonly ${r.fieldName}: ${r.decl};${maybeComment(r.comment)}`;
-    })}
+      ${relations.filter((r) => r.kind === "abstract").map((r) => {
+		return code`${relationDocBlock(fieldDocs, r.fieldName, entityName)}${r.line}${maybeComment(r.comment)}`;
+	})}
+      ${relations.filter((r) => r.kind === "concrete").map((r) => {
+		return 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 code`${relationDocBlock(fieldDocs, r.fieldName, entityName)}declare readonly ${r.fieldName}: ${r.decl};${maybeComment(r.comment)}`;
+	})}
 
       get id(): ${entity.idName} {
-        return this.idMaybe || ${symbols_1.failNoIdYet}("${entityName}");
+        return this.idMaybe || ${failNoIdYet}("${entityName}");
       }
 
       get idMaybe(): ${entity.idName} | undefined {
         ${idMaybeCode}
       }
 
-      get idTagged(): ${symbols_1.TaggedId} {
-        return this.idTaggedMaybe || ${symbols_1.failNoIdYet}("${entityName}");
+      get idTagged(): ${TaggedId} {
+        return this.idTaggedMaybe || ${failNoIdYet}("${entityName}");
       }
 
-      get idTaggedMaybe(): ${symbols_1.TaggedId} | undefined {
-        return ${symbols_1.getField}(this, "id");
+      get idTaggedMaybe(): ${TaggedId} | undefined {
+        return ${getField}(this, "id");
       }
 
       ${primitives}    
 
-      ${tsdoc_1.tsdocComments.entity.setPartial}
+      ${tsdocComments.entity.setPartial}
       set(opts: Partial<${entity.optsName}>): void {
-        ${symbols_1.setOpts}(this as any as ${entityName}, opts);
+        ${setOpts}(this as any as ${entityName}, opts);
       }
 
-      ${tsdoc_1.tsdocComments.entity.setPartial}
-      setPartial(opts: ${symbols_1.PartialOrNull}<${entity.optsName}>): void {
-        ${symbols_1.setOpts}(this as any as ${entityName}, opts as ${symbols_1.OptsOf}<${entityName}>, { partial: true });
+      ${tsdocComments.entity.setPartial}
+      setPartial(opts: ${PartialOrNull}<${entity.optsName}>): void {
+        ${setOpts}(this as any as ${entityName}, opts as ${OptsOf}<${entityName}>, { partial: true });
       }
 
-      ${tsdoc_1.tsdocComments.entity.setDeepPartial}
-      setDeepPartial(opts: ${symbols_1.DeepPartialOrNull}<${entityName}>): Promise<void> {
-        return ${symbols_1.updatePartial}(this as any as ${entityName}, opts);
+      ${tsdocComments.entity.setDeepPartial}
+      setDeepPartial(opts: ${DeepPartialOrNull}<${entityName}>): Promise<void> {
+        return ${updatePartial}(this as any as ${entityName}, opts);
       }
 
-      ${tsdoc_1.tsdocComments.entity.changes}
-      get changes(): ${symbols_1.Changes}<${entityName}${maybeOtherTypeChanges}> {
-        return ${symbols_1.newChangesProxy}(this) as any;
+      ${tsdocComments.entity.changes}
+      get changes(): ${Changes}<${entityName}${maybeOtherTypeChanges}> {
+        return ${newChangesProxy}(this) as any;
       }
 
-      ${maybeIsSoftDeleted}
+      ${maybeSoftDeleteMethods}
 
-      ${tsdoc_1.tsdocComments.entity.load}
-      load<U, V>(fn: (lens: ${symbols_1.Lens}<${entity.type}>) => ${symbols_1.Lens}<U, V>, opts: { sql?: boolean } = {}): Promise<V> {
-        return ${symbols_1.loadLens}(this as any as ${entityName}, fn, opts);
+      ${tsdocComments.entity.load}
+      load<U, V>(fn: (lens: ${Lens}<${entity.type}>) => ${Lens}<U, V>, opts: { sql?: boolean } = {}): Promise<V> {
+        return ${loadLens}(this as any as ${entityName}, fn, opts);
       }
 
-      ${tsdoc_1.tsdocComments.entity.populate}
-      populate<const H extends ${symbols_1.LoadHint}<${entityName}>>(hint: H): Promise<${symbols_1.Loaded}<${entityName}, H>>;
-      populate<const H extends ${symbols_1.LoadHint}<${entityName}>>(opts: { hint: H, forceReload?: boolean }): Promise<${symbols_1.Loaded}<${entityName}, H>>;
-      populate<const H extends ${symbols_1.LoadHint}<${entityName}>, V>(hint: H, fn: (${varName}: Loaded<${entityName}, H>) => V): Promise<V>;
-      populate<const H extends ${symbols_1.LoadHint}<${entityName}>, V>(opts: { hint: H, forceReload?: boolean }, fn: (${varName}: Loaded<${entityName}, H>) => V): Promise<V>;
-      populate<const H extends ${symbols_1.LoadHint}<${entityName}>, V>(hintOrOpts: any, fn?: (${varName}: Loaded<${entityName}, H>) => V): Promise<${symbols_1.Loaded}<${entityName}, H> | V> {
+      ${tsdocComments.entity.populate}
+      populate<const H extends ${LoadHint}<${entityName}>>(hint: H): Promise<${Loaded}<${entityName}, H>>;
+      populate<const H extends ${LoadHint}<${entityName}>>(opts: { hint: H, forceReload?: boolean }): Promise<${Loaded}<${entityName}, H>>;
+      populate<const H extends ${LoadHint}<${entityName}>, V>(hint: H, fn: (${varName}: Loaded<${entityName}, H>) => V): Promise<V>;
+      populate<const H extends ${LoadHint}<${entityName}>, V>(opts: { hint: H, forceReload?: boolean }, fn: (${varName}: Loaded<${entityName}, H>) => V): Promise<V>;
+      populate<const H extends ${LoadHint}<${entityName}>, V>(hintOrOpts: any, fn?: (${varName}: Loaded<${entityName}, H>) => V): Promise<${Loaded}<${entityName}, H> | V> {
         return this.em.populate(this as any as ${entityName}, hintOrOpts, fn);
       }
 
-      ${tsdoc_1.tsdocComments.entity.isLoaded}
-      isLoaded<const H extends ${symbols_1.LoadHint}<${entityName}>>(hint: H): this is ${symbols_1.Loaded}<${entityName}${maybeOtherLoaded}, H> {
-        return ${symbols_1.isLoaded}(this as any as ${entityName}, hint);
+      ${tsdocComments.entity.isLoaded}
+      isLoaded<const H extends ${LoadHint}<${entityName}>>(hint: H): this is ${Loaded}<${entityName}${maybeOtherLoaded}, H> {
+        return ${isLoaded}(this as any as ${entityName}, hint);
       }
 
-      ${tsdoc_1.tsdocComments.entity.toJSON}
+      ${tsdocComments.entity.toJSON}
       toJSON(): object;
-      toJSON<const H extends ${symbols_1.ToJsonHint}<${entityName}>>(hint: H): Promise<${symbols_1.JsonPayload}<${entityName}, H>>;
+      toJSON<const H extends ${ToJsonHint}<${entityName}>>(hint: H): Promise<${JsonPayload}<${entityName}, H>>;
       toJSON(hint?: any): object {
-        return !hint || typeof hint === "string" ? super.toJSON() : ${symbols_1.toJSON}(this, hint);
+        return !hint || typeof hint === "string" ? super.toJSON() : ${toJSON}(this, hint);
       }
     }
   `;
 }
 function fieldHasDefaultValue(field) {
-    let { columnDefault } = field;
-    // If there's no default at all, return false
-    if (columnDefault === null) {
-        return false;
-    }
-    // Even though default is defined as a `number | boolean | string | null`, in reality pg-structure
-    // only ever returns a `string | null`, so we handle that here
-    columnDefault = columnDefault.toString();
-    const fieldType = field.kind === "primitive" ? field.fieldType : "number";
-    // Try to validate that we actually got a primitive value and not arbitrary SQL
-    return ((fieldType === "number" && !isNaN(parseInt(columnDefault))) ||
-        (fieldType === "bigint" && !isNaN(parseInt(columnDefault))) ||
-        (fieldType === "string" && /^'.*'$/.test(columnDefault)) ||
-        (fieldType === "boolean" && ["true", "false"].includes(columnDefault)));
+	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) => [
-        (0, ts_poet_1.code) `export type ${pf.fieldType} = ${pf.components.map((c) => (0, ts_poet_1.code) `| ${c.otherEntity.type}`)};`,
-        (0, ts_poet_1.code) `export function get${pf.fieldType}Constructors(): ${symbols_1.MaybeAbstractEntityConstructor}<${pf.fieldType}>[] {
-      return [${pf.components.map((c) => (0, ts_poet_1.code) `${c.otherEntity.typeSymbol},`)}];
+	return meta.polymorphics.flatMap((pf) => [
+		code`export type ${pf.fieldType} = ${pf.components.map((c) => code`| ${c.otherEntity.type}`)};`,
+		code`export function get${pf.fieldType}Constructors(): ${MaybeAbstractEntityConstructor}<${pf.fieldType}>[] {
+      return [${pf.components.map((c) => code`${c.otherEntity.typeSymbol},`)}];
     }`,
-        (0, ts_poet_1.code) `export function is${pf.fieldType}(maybeEntity: unknown): maybeEntity is ${pf.fieldType} {
-      return ${symbols_1.isEntity}(maybeEntity) && get${pf.fieldType}Constructors().some((type) => maybeEntity instanceof type);
-    }`,
-    ]);
+		code`export function is${pf.fieldType}(maybeEntity: unknown): maybeEntity is ${pf.fieldType} {
+      return ${isEntity}(maybeEntity) && get${pf.fieldType}Constructors().some((type) => maybeEntity instanceof type);
+    }`
+	]);
 }
 function generateDefaultValues(config, meta, configName) {
-    // Skip sync defaults b/c we'll just stomp the getter; leave async in case they're RQFs
-    // where the row must fundamentally be inserted with a dummy value before the real value is calced.
-    function notSync(field) {
-        return "derived" in field && field.derived !== "sync";
-    }
-    const primitives = meta.primitives
-        .filter((field) => fieldHasDefaultValue(field))
-        .filter(notSync)
-        .map(({ fieldName, columnDefault }) => {
-        return (0, ts_poet_1.code) `${configName}.setDefault("${fieldName}", ${columnDefault});`;
-    });
-    const pgEnums = meta.pgEnums
-        .filter((field) => !!field.columnDefault)
-        .map(({ fieldName, columnDefault }) => {
-        return (0, ts_poet_1.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)) ||
-            (0, utils_1.fail)(`Invalid default value ${columnDefault} for ${meta.tableName}.${columnName}`);
-        return (0, ts_poet_1.code) `${configName}.setDefault("${fieldName}", ${enumType}.${(0, change_case_1.pascalCase)(defaultRow.code)});`;
-    });
-    return [...primitives, ...enums, ...pgEnums];
+	function notSync(field) {
+		return "derived" in field && field.derived !== "sync";
+	}
+	const primitives = meta.primitives.filter((field) => fieldHasDefaultValue(field)).filter(notSync).map(({ fieldName, columnDefault }) => {
+		return code`${configName}.setDefault("${fieldName}", ${columnDefault});`;
+	});
+	const pgEnums = meta.pgEnums.filter((field) => !!field.columnDefault).map(({ fieldName, columnDefault }) => {
+		return 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)) || fail(`Invalid default value ${columnDefault} for ${meta.tableName}.${columnName}`);
+		return code`${configName}.setDefault("${fieldName}", ${enumType}.${pascalCase(defaultRow.code)});`;
+	});
+	return [
+		...primitives,
+		...enums,
+		...pgEnums
+	];
 }
 function generateDefaultValidationRules(db, meta, configName) {
-    // Add required rules for all not-null columns
-    const fields = [...meta.primitives, ...meta.enums, ...meta.manyToOnes, ...meta.polymorphics];
-    const rules = fields
-        .filter((p) => p.notNull)
-        .map((p) => {
-        const { fieldName } = p;
-        const isReactive = "derived" in p && p.derived === "async";
-        if (isReactive) {
-            return (0, ts_poet_1.code) `${configName}.addRule("${fieldName}", ${symbols_1.newRequiredRule}("${fieldName}"));`;
-        }
-        else {
-            return (0, ts_poet_1.code) `${configName}.addRule(${symbols_1.newRequiredRule}("${fieldName}"));`;
-        }
-    });
-    // Add STI discriminator cannot change
-    if (meta.stiDiscriminatorField) {
-        const field = meta.enums.find((e) => e.fieldName === meta.stiDiscriminatorField) ?? (0, utils_1.fail)("STI field not found");
-        rules.push((0, ts_poet_1.code) `${configName}.addRule(${symbols_1.cannotBeUpdated}("${field.fieldName}"));`);
-    }
-    // Add STI type must match
-    const stiEntities = (0, inheritance_1.getStiEntities)(db.entities);
-    if (stiEntities.size > 0) {
-        for (const m2o of meta.manyToOnes) {
-            // The `m2o.otherEntity` may already be pointing at the subtype, but stiEntities has subtypes in it as well...
-            const target = stiEntities.get(m2o.otherEntity.name);
-            if (target && m2o.otherEntity.name !== target.base.name) {
-                rules.push((0, ts_poet_1.code) `${configName}.addRule("${m2o.fieldName}", ${symbols_1.mustBeSubType}("${m2o.fieldName}"));`);
-            }
-        }
-    }
-    // Add subtype specialization must match
-    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((0, ts_poet_1.code) `${configName}.addRule("${m2o.fieldName}", ${symbols_1.mustBeSubType}("${m2o.fieldName}"));`);
-        });
-    }
-    return rules;
+	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 code`${configName}.addRule(${newRequiredLazyFieldRule}("${fieldName}"));`;
+		else if (isReactive) return code`${configName}.addRule("${fieldName}", ${newRequiredRule}("${fieldName}"));`;
+		else return code`${configName}.addRule(${newRequiredRule}("${fieldName}"));`;
+	});
+	if (meta.stiDiscriminatorField) {
+		const field = meta.enums.find((e) => e.fieldName === meta.stiDiscriminatorField) ?? fail("STI field not found");
+		rules.push(code`${configName}.addRule(${cannotBeUpdated}("${field.fieldName}"));`);
+	}
+	const stiEntities = 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(code`${configName}.addRule("${m2o.fieldName}", ${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(code`${configName}.addRule("${m2o.fieldName}", ${mustBeSubType}("${m2o.fieldName}"));`);
+	});
+	return rules;
 }
-// Make our opts type
 function generateOptsFields(meta) {
-    const primitives = meta.primitives.map((field) => {
-        const { fieldName, fieldType, notNull, derived } = field;
-        if (derived)
-            return (0, ts_poet_1.code) ``;
-        return (0, ts_poet_1.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) {
-            // Don't include the discriminator as an opt b/c we'll infer it from the instance type
-            return (0, ts_poet_1.code) ``;
-        }
-        else if (isArray) {
-            // Arrays are always optional and we'll default to `[]`
-            return (0, ts_poet_1.code) `${fieldName}?: ${enumType}[];`;
-        }
-        else {
-            return (0, ts_poet_1.code) `${fieldName}${maybeOptionalOrDefault(field)}: ${enumType}${maybeUnionNull(notNull)};`;
-        }
-    });
-    const pgEnums = meta.pgEnums.map((field) => {
-        const { fieldName, enumType, notNull } = field;
-        return (0, ts_poet_1.code) `${fieldName}${maybeOptionalOrDefault(field)}: ${enumType}${maybeUnionNull(notNull)};`;
-    });
-    const m2o = meta.manyToOnes
-        .filter(({ derived }) => !derived) // Skip ReactiveReferences (derived m2o)
-        // If a `group: { subType: SmallPublisherGroup }` is specializing this relation, that's
-        // fine for most things, but not the `SmallPublisherOpts`, b/c it will break the contravariance
-        // of `Publisher.setOpts` and `SmallPublisher.setOpts`
-        .filter(({ fieldName }) => !meta.baseType?.manyToOnes.find((o) => o.fieldName === fieldName))
-        .map((field) => {
-        const { fieldName, otherEntity, notNull } = field;
-        const maybeNull = maybeUnionNull(notNull);
-        return (0, ts_poet_1.code) `${fieldName}${maybeOptionalOrDefault(field)}: ${otherEntity.type} | ${otherEntity.idType} ${maybeNull};`;
-    });
-    const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${otherEntity.type} | null;`;
-    });
-    const o2m = meta.oneToManys.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${otherEntity.type}[];`;
-    });
-    const m2m = meta.manyToManys
-        .filter(({ derived }) => !derived) // Skip ReactiveManyToManys
-        .map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${otherEntity.type}[];`;
-    });
-    const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${enumType}[];`;
-    });
-    const polys = meta.polymorphics.map((field) => {
-        const { fieldName, notNull, fieldType } = field;
-        return (0, ts_poet_1.code) `${fieldName}${maybeOptionalOrDefault(field)}: ${fieldType};`;
-    });
-    return [...primitives, ...enums, ...pgEnums, ...m2o, ...polys, ...o2o, ...o2m, ...m2m, ...m2mEnum];
+	const primitives = meta.primitives.map((field) => {
+		const { fieldName, fieldType, notNull, derived } = field;
+		if (derived) return code``;
+		return 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 code``;
+		else if (isArray) return code`${fieldName}?: ${enumType}[];`;
+		else return code`${fieldName}${maybeOptionalOrDefault(field)}: ${enumType}${maybeUnionNull(notNull)};`;
+	});
+	const pgEnums = meta.pgEnums.map((field) => {
+		const { fieldName, enumType, notNull } = field;
+		return 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 code`${fieldName}${maybeOptionalOrDefault(field)}: ${otherEntity.type} | ${otherEntity.idType} ${maybeNull};`;
+	});
+	const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}?: ${otherEntity.type} | null;`;
+	});
+	const o2m = meta.oneToManys.map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}?: ${otherEntity.type}[];`;
+	});
+	const m2m = meta.manyToManys.filter(({ derived }) => !derived).map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}?: ${otherEntity.type}[];`;
+	});
+	const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
+		return code`${fieldName}?: ${enumType}[];`;
+	});
+	const polys = meta.polymorphics.map((field) => {
+		const { fieldName, notNull, fieldType } = field;
+		return code`${fieldName}${maybeOptionalOrDefault(field)}: ${fieldType};`;
+	});
+	return [
+		...primitives,
+		...enums,
+		...pgEnums,
+		...m2o,
+		...polys,
+		...o2o,
+		...o2m,
+		...m2m,
+		...m2mEnum
+	];
 }
-// Make our fields type
 function generateFieldsType(meta, idType) {
-    const id = (0, ts_poet_1.code) `id: { kind: "primitive"; type: ${idType}; unique: ${true}; nullable: never };`;
-    const primitives = meta.primitives.map((field) => {
-        const { fieldName, fieldType, notNull, unique, derived } = field;
-        return (0, ts_poet_1.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) {
-            // Arrays are always optional and we'll default to `[]`
-            return (0, ts_poet_1.code) `${fieldName}: { kind: "enum"; type: ${enumType}[]; nullable: never };`;
-        }
-        else {
-            return (0, ts_poet_1.code) `${fieldName}: { kind: "enum"; type: ${enumType}; nullable: ${undefinedOrNever(notNull)} };`;
-        }
-    });
-    const pgEnums = meta.pgEnums.map(({ fieldName, enumType, notNull }) => {
-        const nullable = undefinedOrNever(notNull);
-        return (0, ts_poet_1.code) `${fieldName}: { kind: "enum"; type: ${enumType}; nullable: ${nullable}; native: true };`;
-    });
-    const m2o = meta.manyToOnes.map(({ fieldName, otherEntity, notNull, derived }) => {
-        return (0, ts_poet_1.code) `${fieldName}: { kind: "m2o"; type: ${otherEntity.type}; nullable: ${undefinedOrNever(notNull)}, derived: ${derived !== false} };`;
-    });
-    const polys = meta.polymorphics.map(({ fieldName, notNull, fieldType }) => {
-        return (0, ts_poet_1.code) `${fieldName}: { kind: "poly"; type: ${fieldType}; nullable: ${undefinedOrNever(notNull)} };`;
-    });
-    const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}: { kind: "m2m"; type: ${otherEntity.type} };`;
-    });
-    const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
-        return (0, ts_poet_1.code) `${fieldName}: { kind: "m2mEnum"; type: ${enumType} };`;
-    });
-    const o2m = meta.oneToManys.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}: { kind: "o2m"; type: ${otherEntity.type} };`;
-    });
-    const lo2m = meta.largeOneToManys.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}: { kind: "o2m"; type: ${otherEntity.type} };`;
-    });
-    return [id, ...primitives, ...enums, ...pgEnums, ...m2o, ...polys, ...m2m, ...m2mEnum, ...o2m, ...lo2m];
+	const id = code`id: { kind: "primitive"; type: ${idType}; unique: ${true}; nullable: never; };`;
+	const primitives = meta.primitives.map((field) => {
+		const { fieldName, fieldType, notNull, unique, derived } = field;
+		return 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 code`${fieldName}: { kind: "enum"; type: ${enumType}[]; nullable: never; };`;
+		else return 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 code`${fieldName}: { kind: "enum"; type: ${enumType}; nullable: ${nullable}; native: true; };`;
+	});
+	const m2o = meta.manyToOnes.map((field) => {
+		const { fieldName, otherEntity, notNull, derived } = field;
+		return 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 code`${fieldName}: { kind: "poly"; type: ${fieldType}; nullable: ${undefinedOrNever(notNull)} };`;
+	});
+	const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}: { kind: "m2m"; type: ${otherEntity.type} };`;
+	});
+	const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
+		return code`${fieldName}: { kind: "m2mEnum"; type: ${enumType} };`;
+	});
+	const o2m = meta.oneToManys.map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}: { kind: "o2m"; type: ${otherEntity.type} };`;
+	});
+	const o2o = meta.oneToOnes.map((field) => {
+		return code`${field.fieldName}: { kind: "o2o"; type: ${field.otherEntity.type} };`;
+	});
+	const lo2m = meta.largeOneToManys.map(({ fieldName, otherEntity }) => {
+		return 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.
+* Polymorphic component writes remain unsupported, so their policies are conservative.
+*/
+function generateColumnsType(meta) {
+	const columns = { id: code`{ type: ${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 = columnPolicyType(meta, field);
+		if (field.kind === "primitive") columns[field.columnName] = code`{ type: ${field.fieldType}; ${policy} }`;
+		else if (field.kind === "m2o") columns[field.columnName] = code`{ type: ${IdOf}<${field.otherEntity.type}>; entity: ${field.otherEntity.type}; ${policy} }`;
+		else {
+			const array = field.kind === "enum" && field.isArray ? "[]" : "";
+			columns[field.columnName] = code`{ type: ${field.enumType}${array}; ${policy} }`;
+		}
+	}
+	for (const field of meta.polymorphics) for (const component of field.components) columns[component.columnName] = code`{ type: ${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 code`nullable: ${!column.columnNotNull}; insert: "${insert}"; update: ${!primaryKey && !column.columnGenerated};`;
 }
-// We know the OptIds types are only used in partials, so we make everything optional.
-// This especially needs to be the case b/c both `book: ...` and `bookId: ...` will be
-// in the partial type and of course the caller will only be setting one.
 function generateOptIdsFields(meta) {
-    const m2o = meta.manyToOnes
-        .filter(({ derived }) => !derived) // Skip ReactiveReferences
-        .map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}Id?: ${otherEntity.idType} | null;`;
-    });
-    const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}Id?: ${otherEntity.idType} | null;`;
-    });
-    const o2m = meta.oneToManys.map(({ singularName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${singularName}Ids?: ${otherEntity.idType}[] | null;`;
-    });
-    const m2m = meta.manyToManys
-        .filter(({ derived }) => !derived) // Skip ReactiveManyToManys
-        .map(({ singularName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${singularName}Ids?: ${otherEntity.idType}[] | null;`;
-    });
-    const polys = meta.polymorphics.map(({ fieldName, fieldType }) => {
-        return (0, ts_poet_1.code) `${fieldName}Id?:  ${symbols_1.IdOf}<${fieldType}> | null;`;
-    });
-    return [...m2o, ...polys, ...o2o, ...o2m, ...m2m];
+	const m2o = meta.manyToOnes.filter(({ derived }) => !derived).map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}Id?: ${otherEntity.idType} | null;`;
+	});
+	const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}Id?: ${otherEntity.idType} | null;`;
+	});
+	const o2m = meta.oneToManys.map(({ singularName, otherEntity }) => {
+		return code`${singularName}Ids?: ${otherEntity.idType}[] | null;`;
+	});
+	const m2m = meta.manyToManys.filter(({ derived }) => !derived).map(({ singularName, otherEntity }) => {
+		return code`${singularName}Ids?: ${otherEntity.idType}[] | null;`;
+	});
+	const polys = meta.polymorphics.map(({ fieldName, fieldType }) => {
+		return code`${fieldName}Id?:  ${IdOf}<${fieldType}> | null;`;
+	});
+	return [
+		...m2o,
+		...polys,
+		...o2o,
+		...o2m,
+		...m2m
+	];
 }
 function generateFilterFields(metasByName, meta) {
-    // Always allow filtering on null to do "child.id is null" for detecting "has no children"
-    const maybeId = meta.baseClassName ? [] : [(0, ts_poet_1.code) `id?: ${symbols_1.ValueFilter}<${meta.entity.idName}, never> | null;`];
-    const primitives = meta.primitives.map(({ fieldName, fieldType, notNull }) => {
-        if (fieldType === "boolean") {
-            return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.BooleanFilter}<${nullOrNever(notNull)}>;`;
-        }
-        else {
-            return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.ValueFilter}<${fieldType}, ${nullOrNever(notNull)}>;`;
-        }
-    });
-    const enums = meta.enums.map(({ fieldName, enumType, notNull, isArray }) => {
-        const maybeArray = isArray ? "[]" : "";
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.ValueFilter}<${enumType}${maybeArray}, ${nullOrNever(notNull)}>;`;
-    });
-    const pgEnums = meta.pgEnums.map(({ fieldName, enumType, notNull }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.ValueFilter}<${enumType}, ${nullOrNever(notNull)}>;`;
-    });
-    const m2o = meta.manyToOnes.flatMap(({ fieldName, otherEntity, notNull }) => {
-        const otherMeta = metasByName[otherEntity.name] ?? (0, utils_1.fail)(`Could not find metadata for ${otherEntity.name}`);
-        return [
-            (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${symbols_1.FilterOf}<${otherEntity.type}>, ${nullOrNever(notNull)}>;`,
-            ...otherMeta.subTypes.map((st) => {
-                return (0, ts_poet_1.code) `${fieldName}${st.name}?: ${symbols_1.EntityFilter}<${st.entity.type}, ${st.entity.idType}, ${symbols_1.FilterOf}<${st.entity.type}>, ${nullOrNever(notNull)}>;`;
-            }),
-        ];
-    });
-    const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${symbols_1.FilterOf}<${otherEntity.type}>, null | undefined>;`;
-    });
-    const o2m = meta.oneToManys.flatMap(({ fieldName, otherEntity, otherColumnNotNull }) => {
-        const otherMeta = metasByName[otherEntity.name] ?? (0, utils_1.fail)(`Could not find metadata for ${otherEntity.name}`);
-        return [
-            (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${symbols_1.FilterOf}<${otherEntity.type}>, null | undefined>;`,
-            ...otherMeta.subTypes.map((st) => {
-                return (0, ts_poet_1.code) `${fieldName}${st.name}?: ${symbols_1.EntityFilter}<${st.entity.type}, ${st.entity.idType}, ${symbols_1.FilterOf}<${st.entity.type}>, ${nullOrNever(otherColumnNotNull)}>;`;
-            }),
-        ];
-    });
-    const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${symbols_1.FilterOf}<${otherEntity.type}>, null | undefined>;`;
-    });
-    // Enum m2m filters are membership filters, e.g. `{ logoColors: Color.Red }` / `{ logoColors: [Red, Green] }`.
-    const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.ValueFilter}<${enumType}, null | undefined>;`;
-    });
-    const polys = meta.polymorphics.flatMap(({ fieldName, fieldType, components, notNull }) => {
-        return [
-            (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityFilter}<${fieldType}, ${symbols_1.IdOf}<${fieldType}>, never, ${nullOrNever(notNull)}>;`,
-            ...components.map((comp) => {
-                const { type } = comp.otherEntity;
-                return (0, ts_poet_1.code) `${fieldName}${type}?: ${symbols_1.EntityFilter}<${type}, ${symbols_1.IdOf}<${type}>, ${symbols_1.FilterOf}<${type}>, null>;`;
-            }),
-        ];
-    });
-    return [...maybeId, ...primitives, ...enums, ...pgEnums, ...m2o, ...o2o, ...o2m, ...m2m, ...m2mEnum, ...polys];
+	const maybeId = meta.baseClassName ? [] : [code`id?: ${ValueFilter}<${meta.entity.idName}, never> | null;`];
+	const primitives = meta.primitives.map(({ fieldName, fieldType, notNull }) => {
+		if (fieldType === "boolean") return code`${fieldName}?: ${BooleanFilter}<${nullOrNever(notNull)}>;`;
+		else return code`${fieldName}?: ${ValueFilter}<${fieldType}, ${nullOrNever(notNull)}>;`;
+	});
+	const enums = meta.enums.map(({ fieldName, enumType, notNull, isArray }) => {
+		return code`${fieldName}?: ${ValueFilter}<${enumType}${isArray ? "[]" : ""}, ${nullOrNever(notNull)}>;`;
+	});
+	const pgEnums = meta.pgEnums.map(({ fieldName, enumType, notNull }) => {
+		return code`${fieldName}?: ${ValueFilter}<${enumType}, ${nullOrNever(notNull)}>;`;
+	});
+	const m2o = meta.manyToOnes.flatMap(({ fieldName, otherEntity, notNull }) => {
+		const otherMeta = metasByName[otherEntity.name] ?? fail(`Could not find metadata for ${otherEntity.name}`);
+		return [code`${fieldName}?: ${EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${FilterOf}<${otherEntity.type}>, ${nullOrNever(notNull)}>;`, ...otherMeta.subTypes.map((st) => {
+			return code`${fieldName}${st.name}?: ${EntityFilter}<${st.entity.type}, ${st.entity.idType}, ${FilterOf}<${st.entity.type}>, ${nullOrNever(notNull)}>;`;
+		})];
+	});
+	const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}?: ${EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${FilterOf}<${otherEntity.type}>, null | undefined>;`;
+	});
+	const o2m = meta.oneToManys.flatMap(({ fieldName, otherEntity, otherColumnNotNull }) => {
+		const otherMeta = metasByName[otherEntity.name] ?? fail(`Could not find metadata for ${otherEntity.name}`);
+		return [code`${fieldName}?: ${EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${FilterOf}<${otherEntity.type}>, null | undefined>;`, ...otherMeta.subTypes.map((st) => {
+			return code`${fieldName}${st.name}?: ${EntityFilter}<${st.entity.type}, ${st.entity.idType}, ${FilterOf}<${st.entity.type}>, ${nullOrNever(otherColumnNotNull)}>;`;
+		})];
+	});
+	const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}?: ${EntityFilter}<${otherEntity.type}, ${otherEntity.idType}, ${FilterOf}<${otherEntity.type}>, null | undefined>;`;
+	});
+	const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
+		return code`${fieldName}?: ${ValueFilter}<${enumType}, null | undefined>;`;
+	});
+	const polys = meta.polymorphics.flatMap(({ fieldName, fieldType, components, notNull }) => {
+		return [code`${fieldName}?: ${EntityFilter}<${fieldType}, ${IdOf}<${fieldType}>, never, ${nullOrNever(notNull)}>;`, ...components.map((comp) => {
+			const { type } = comp.otherEntity;
+			return code`${fieldName}${type}?: ${EntityFilter}<${type}, ${IdOf}<${type}>, ${FilterOf}<${type}>, null>;`;
+		})];
+	});
+	return [
+		...maybeId,
+		...primitives,
+		...enums,
+		...pgEnums,
+		...m2o,
+		...o2o,
+		...o2m,
+		...m2m,
+		...m2mEnum,
+		...polys
+	];
 }
 function generateGraphQLFilterFields(metasByName, meta) {
-    const maybeId = meta.baseClassName ? [] : [(0, ts_poet_1.code) `id?: ${symbols_1.ValueGraphQLFilter}<${meta.entity.idName}>;`];
-    const primitives = meta.primitives.map(({ fieldName, fieldType }) => {
-        if (fieldType === "boolean") {
-            return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.BooleanGraphQLFilter};`;
-        }
-        else {
-            return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.ValueGraphQLFilter}<${fieldType}>;`;
-        }
-    });
-    const enums = meta.enums.map(({ fieldName, enumType, isArray }) => {
-        const maybeArray = isArray ? "[]" : "";
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.ValueGraphQLFilter}<${enumType}${maybeArray}>;`;
-    });
-    const pgEnums = meta.pgEnums.map(({ fieldName, enumType }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.ValueGraphQLFilter}<${enumType}>;`;
-    });
-    const m2o = meta.manyToOnes.flatMap(({ fieldName, otherEntity, notNull }) => {
-        const otherMeta = metasByName[otherEntity.name];
-        return [
-            (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${symbols_1.GraphQLFilterOf}<${otherEntity.type}>, ${nullOrNever(notNull)}>;`,
-            (0, ts_poet_1.code) `${fieldName}Id?: ${symbols_1.ValueGraphQLFilter}<${otherEntity.idType}>;`,
-            ...otherMeta.subTypes.map((st) => {
-                return (0, ts_poet_1.code) `${fieldName}${st.name}?: ${symbols_1.EntityGraphQLFilter}<${st.entity.type}, ${st.entity.idType}, ${symbols_1.GraphQLFilterOf}<${st.entity.type}>, ${nullOrNever(notNull)}>;`;
-            }),
-        ];
-    });
-    const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${symbols_1.GraphQLFilterOf}<${otherEntity.type}>, null | undefined>;`;
-    });
-    const o2m = meta.oneToManys.flatMap(({ fieldName, otherEntity, otherColumnNotNull }) => {
-        const otherMeta = metasByName[otherEntity.name] ?? (0, utils_1.fail)(`Could not find metadata for ${otherEntity.name}`);
-        return [
-            (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${symbols_1.GraphQLFilterOf}<${otherEntity.type}>, null | undefined>;`,
-            ...otherMeta.subTypes.map((st) => {
-                return (0, ts_poet_1.code) `${fieldName}${st.name}?: ${symbols_1.EntityGraphQLFilter}<${st.entity.type}, ${st.entity.idType}, ${symbols_1.GraphQLFilterOf}<${st.entity.type}>, ${nullOrNever(otherColumnNotNull)}>;`;
-            }),
-        ];
-    });
-    const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${symbols_1.GraphQLFilterOf}<${otherEntity.type}>, null | undefined>;`;
-    });
-    const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.ValueGraphQLFilter}<${enumType}>;`;
-    });
-    const polys = meta.polymorphics.flatMap(({ fieldName, fieldType, components, notNull }) => {
-        return [
-            (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.EntityGraphQLFilter}<${fieldType}, ${symbols_1.IdOf}<${fieldType}>, never, ${nullOrNever(notNull)}>;`,
-            (0, ts_poet_1.code) `${fieldName}Id?: ${symbols_1.ValueGraphQLFilter}<${symbols_1.IdOf}<${fieldType}>>;`,
-            ...components.map((comp) => {
-                const { type } = comp.otherEntity;
-                return (0, ts_poet_1.code) `${fieldName}${type}?: ${symbols_1.EntityGraphQLFilter}<${type}, ${symbols_1.IdOf}<${type}>, ${symbols_1.FilterOf}<${type}>, null>;`;
-            }),
-        ];
-    });
-    return [...maybeId, ...primitives, ...enums, ...pgEnums, ...m2o, ...o2o, ...o2m, ...m2m, ...m2mEnum, ...polys];
+	const maybeId = meta.baseClassName ? [] : [code`id?: ${ValueGraphQLFilter}<${meta.entity.idName}>;`];
+	const primitives = meta.primitives.map(({ fieldName, fieldType }) => {
+		if (fieldType === "boolean") return code`${fieldName}?: ${BooleanGraphQLFilter};`;
+		else return code`${fieldName}?: ${ValueGraphQLFilter}<${fieldType}>;`;
+	});
+	const enums = meta.enums.map(({ fieldName, enumType, isArray }) => {
+		return code`${fieldName}?: ${ValueGraphQLFilter}<${enumType}${isArray ? "[]" : ""}>;`;
+	});
+	const pgEnums = meta.pgEnums.map(({ fieldName, enumType }) => {
+		return code`${fieldName}?: ${ValueGraphQLFilter}<${enumType}>;`;
+	});
+	const m2o = meta.manyToOnes.flatMap(({ fieldName, otherEntity, notNull }) => {
+		const otherMeta = metasByName[otherEntity.name];
+		return [
+			code`${fieldName}?: ${EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${GraphQLFilterOf}<${otherEntity.type}>, ${nullOrNever(notNull)}>;`,
+			code`${fieldName}Id?: ${ValueGraphQLFilter}<${otherEntity.idType}>;`,
+			...otherMeta.subTypes.map((st) => {
+				return code`${fieldName}${st.name}?: ${EntityGraphQLFilter}<${st.entity.type}, ${st.entity.idType}, ${GraphQLFilterOf}<${st.entity.type}>, ${nullOrNever(notNull)}>;`;
+			})
+		];
+	});
+	const o2o = meta.oneToOnes.map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}?: ${EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${GraphQLFilterOf}<${otherEntity.type}>, null | undefined>;`;
+	});
+	const o2m = meta.oneToManys.flatMap(({ fieldName, otherEntity, otherColumnNotNull }) => {
+		const otherMeta = metasByName[otherEntity.name] ?? fail(`Could not find metadata for ${otherEntity.name}`);
+		return [code`${fieldName}?: ${EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${GraphQLFilterOf}<${otherEntity.type}>, null | undefined>;`, ...otherMeta.subTypes.map((st) => {
+			return code`${fieldName}${st.name}?: ${EntityGraphQLFilter}<${st.entity.type}, ${st.entity.idType}, ${GraphQLFilterOf}<${st.entity.type}>, ${nullOrNever(otherColumnNotNull)}>;`;
+		})];
+	});
+	const m2m = meta.manyToManys.map(({ fieldName, otherEntity }) => {
+		return code`${fieldName}?: ${EntityGraphQLFilter}<${otherEntity.type}, ${otherEntity.idType}, ${GraphQLFilterOf}<${otherEntity.type}>, null | undefined>;`;
+	});
+	const m2mEnum = meta.manyToManyEnums.map(({ fieldName, enumType }) => {
+		return code`${fieldName}?: ${ValueGraphQLFilter}<${enumType}>;`;
+	});
+	const polys = meta.polymorphics.flatMap(({ fieldName, fieldType, components, notNull }) => {
+		return [
+			code`${fieldName}?: ${EntityGraphQLFilter}<${fieldType}, ${IdOf}<${fieldType}>, never, ${nullOrNever(notNull)}>;`,
+			code`${fieldName}Id?: ${ValueGraphQLFilter}<${IdOf}<${fieldType}>>;`,
+			...components.map((comp) => {
+				const { type } = comp.otherEntity;
+				return code`${fieldName}${type}?: ${EntityGraphQLFilter}<${type}, ${IdOf}<${type}>, ${FilterOf}<${type}>, null>;`;
+			})
+		];
+	});
+	return [
+		...maybeId,
+		...primitives,
+		...enums,
+		...pgEnums,
+		...m2o,
+		...o2o,
+		...o2m,
+		...m2m,
+		...m2mEnum,
+		...polys
+	];
 }
 function generateOrderFields(meta) {
-    const maybeId = meta.baseClassName ? [] : [(0, ts_poet_1.code) `id?: ${symbols_1.OrderBy};`];
-    const primitives = meta.primitives.map(({ fieldName }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.OrderBy};`;
-    });
-    const enums = meta.enums.map(({ fieldName }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.OrderBy};`;
-    });
-    const pgEnums = meta.pgEnums.map(({ fieldName }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${symbols_1.OrderBy};`;
-    });
-    const m2o = meta.manyToOnes.map(({ fieldName, otherEntity }) => {
-        return (0, ts_poet_1.code) `${fieldName}?: ${otherEntity.orderType};`;
-    });
-    return [...maybeId, ...primitives, ...enums, ...pgEnums, ...m2o];
+	const maybeId = meta.baseClassName ? [] : [code`id?: ${OrderBy};`];
+	const primitives = meta.primitives.map(({ fieldName }) => {
+		return code`${fieldName}?: ${OrderBy};`;
+	});
+	const enums = meta.enums.map(({ fieldName }) => {
+		return code`${fieldName}?: ${OrderBy};`;
+	});
+	const pgEnums = meta.pgEnums.map(({ fieldName }) => {
+		return code`${fieldName}?: ${OrderBy};`;
+	});
+	const m2o = meta.manyToOnes.map(({ fieldName, otherEntity }) => {
+		return 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 (0, ts_poet_1.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 (0, ts_poet_1.code) `${withName(fieldName)}?: ${enumType}[];`;
-        }
-        else {
-            return (0, ts_poet_1.code) `${withName(fieldName)}?: ${enumType}${maybeUnionNull(notNull)};`;
-        }
-    });
-    return [...primitives, ...enums];
+	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 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 code`${withName(fieldName)}?: ${enumType}[];`;
+		else return code`${withName(fieldName)}?: ${enumType}${maybeUnionNull(notNull)};`;
+	});
+	return [...primitives, ...enums];
 }
-function createPrimitives(meta, entity) {
-    const primitives = meta.primitives.map((p) => {
-        const { fieldName, fieldType, notNull } = p;
-        const maybeOptional = notNull ? "" : " | undefined";
-        let getter;
-        if (p.derived === "async") {
-            getter = (0, ts_poet_1.code) `
-        abstract readonly ${fieldName}: ${symbols_1.ReactiveField}<${entity.name}, ${p.fieldType}${maybeOptional}>;
+function createPrimitives(meta, entity, fieldDocs) {
+	return meta.primitives.map((p) => {
+		const { fieldName, fieldType, notNull } = p;
+		const maybeOptional = notNull ? "" : " | undefined";
+		if (p.lazy) return code``;
+		let getter;
+		if (p.derived === "async") getter = code`
+        abstract readonly ${fieldName}: ${ReactiveField}<${entity.name}, ${p.fieldType}${maybeOptional}>;
      `;
-        }
-        else if (p.derived === "sync") {
-            getter = (0, ts_poet_1.code) `
+		else if (p.derived === "sync") getter = code`
         abstract get ${fieldName}(): ${fieldType}${maybeOptional};
      `;
-        }
-        else if (p.zodSchema) {
-            getter = (0, ts_poet_1.code) `
-        get ${fieldName}(): ${symbols_1.Zod}.output<typeof ${p.zodSchema}>${maybeOptional} {
-          return ${symbols_1.getField}(this, "${fieldName}");
+		else if (p.zodSchema) getter = code`
+        get ${fieldName}(): ${Zod}.output<typeof ${p.zodSchema}>${maybeOptional} {
+          return ${getField}(this, "${fieldName}");
         }
      `;
-        }
-        else {
-            getter = (0, ts_poet_1.code) `
+		else getter = code`
         get ${fieldName}(): ${fieldType}${maybeOptional} {
-          return ${symbols_1.getField}(this, "${fieldName}");
+          return ${getField}(this, "${fieldName}");
         }
      `;
-        }
-        let setter;
-        // ...technically we should be checking a list of JS keywords
-        const paramName = keywords_1.keywords.includes(fieldName) ? "value" : fieldName;
-        if (p.protected) {
-            // TODO Allow making the getter to be protected as well. And so probably remove it
-            // from the Opts as well. Wonder how that works for required protected fields?
-            //
-            // We have to use a method of `set${fieldName}` because TS enforces getters/setters to have
-            // same access level and currently we're leaving the getter as public.
-            setter = (0, ts_poet_1.code) `
-        protected set${(0, change_case_1.pascalCase)(fieldName)}(${paramName}: ${fieldType}${maybeOptional}) {
-          ${symbols_1.setField}(this, "${fieldName}", ${paramName});
+		let setter;
+		const paramName = keywords.includes(fieldName) ? "value" : fieldName;
+		if (p.protected) setter = code`
+        protected set${pascalCase(fieldName)}(${paramName}: ${fieldType}${maybeOptional}) {
+          ${setField}(this, "${fieldName}", ${paramName});
         }
       `;
-        }
-        else if (p.derived) {
-            setter = "";
-        }
-        else if (p.superstruct) {
-            // We use `value` as the param name to not potentially conflict with the
-            // name of the imported superstruct const that is passed to assert.
-            setter = (0, ts_poet_1.code) `
+		else if (p.derived) setter = "";
+		else if (p.superstruct) setter = code`
         set ${fieldName}(value: ${fieldType}${maybeOptional}) {
           if (value) {
-            ${symbols_1.SSAssert}(value, ${p.superstruct});
+            ${SSAssert}(value, ${p.superstruct});
           }
-          ${symbols_1.setField}(this, "${fieldName}", value);
+          ${setField}(this, "${fieldName}", value);
         }
       `;
-        }
-        else if (p.zodSchema) {
-            // We use `value` as the param name to not potentially conflict with the
-            // name of the imported zod schema that is passed to parse.
-            setter = (0, ts_poet_1.code) `
-        set ${fieldName}(value: ${symbols_1.Zod}.input<typeof ${p.zodSchema}>${maybeOptional}) {
+		else if (p.zodSchema) setter = code`
+        set ${fieldName}(value: ${Zod}.input<typeof ${p.zodSchema}>${maybeOptional}) {
           if (value) {
-            ${symbols_1.setField}(this, "${fieldName}", ${p.zodSchema}.parse(value));
+            ${setField}(this, "${fieldName}", ${p.zodSchema}.parse(value));
           } else {
-            ${symbols_1.setField}(this, "${fieldName}", value);
+            ${setField}(this, "${fieldName}", value);
           }
         }
       `;
-        }
-        else {
-            setter = (0, ts_poet_1.code) `
+		else setter = code`
         set ${fieldName}(${paramName}: ${fieldType}${maybeOptional}) {
-          ${symbols_1.setField}(this, "${fieldName}", ${paramName});
+          ${setField}(this, "${fieldName}", ${paramName});
         }
       `;
-        }
-        return (0, ts_poet_1.code) `${getter} ${setter}`;
-    });
-    return primitives;
+		return code`${fieldDocBlock(fieldDocs, fieldName, entity.name)}${getter} ${setter}`;
+	});
 }
-function createRegularEnums(meta, entity) {
-    return meta.enums
-        .filter((e) => !e.isArray)
-        .flatMap((e) => {
-        const { fieldName, enumType, enumDetailType, enumDetailsType, notNull, enumRows, derived } = e;
-        const maybeOptional = notNull ? "" : " | undefined";
-        const getByCode = (0, ts_poet_1.code) `${enumDetailType}.getByCode(this.${fieldName})`;
-        let getter;
-        if (derived === "async") {
-            getter = (0, ts_poet_1.code) `
-          abstract readonly ${fieldName}: ${symbols_1.ReactiveField}<${entity.name}, ${enumType}${maybeOptional}>;
+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 = code`${enumDetailType}.getByCode(this.${fieldName})`;
+		let getter;
+		if (derived === "async") getter = code`
+          abstract readonly ${fieldName}: ${ReactiveField}<${entity.name}, ${enumType}${maybeOptional}>;
        `;
-        }
-        else if (derived === "sync") {
-            getter = (0, ts_poet_1.code) `
+		else if (derived === "sync") getter = code`
           abstract get ${fieldName}(): ${enumType}${maybeOptional};
        `;
-        }
-        else {
-            getter = (0, ts_poet_1.code) `
+		else getter = code`
           get ${fieldName}(): ${enumType}${maybeOptional} {
-            return ${symbols_1.getField}(this, "${fieldName}");
+            return ${getField}(this, "${fieldName}");
           }
 
           get ${fieldName}Details(): ${enumDetailsType}${maybeOptional} {
-            return ${notNull ? getByCode : (0, ts_poet_1.code) `this.${fieldName} ? ${getByCode} : undefined`};
+            return ${notNull ? getByCode : code`this.${fieldName} ? ${getByCode} : undefined`};
           }
        `;
-        }
-        let setter;
-        if (derived) {
-            setter = (0, ts_poet_1.code) ``;
-        }
-        else {
-            setter = (0, ts_poet_1.code) `
+		let setter;
+		if (derived) setter = code``;
+		else setter = code`
           set ${fieldName}(${fieldName}: ${enumType}${maybeOptional}) {
-            ${symbols_1.setField}(this, "${fieldName}", ${fieldName});
+            ${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) => (0, ts_poet_1.code) `
-          get is${shouldPrefixAccessors ? (0, change_case_1.pascalCase)(fieldName) : ""}${(0, change_case_1.pascalCase)(row.code)}(): boolean {
-            return ${symbols_1.getField}(this, "${fieldName}") === ${enumType}.${(0, change_case_1.pascalCase)(row.code)};
+		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) => code`
+          get is${shouldPrefixAccessors ? pascalCase(fieldName) : ""}${pascalCase(row.code)}(): boolean {
+            return ${getField}(this, "${fieldName}") === ${enumType}.${pascalCase(row.code)};
           }
         `);
-        return [getter, setter, ...accessors];
-    });
+		return [
+			code`${fieldDocBlock(fieldDocs, fieldName, entity.name)}${getter}`,
+			setter,
+			...accessors
+		];
+	});
 }
-function createArrayEnums(meta) {
-    return meta.enums
-        .filter((e) => e.isArray)
-        .flatMap((e) => {
-        const { fieldName, enumType, enumDetailType, enumDetailsType, enumRows } = e;
-        const getter = (0, ts_poet_1.code) `
+function createArrayEnums(meta, fieldDocs) {
+	return meta.enums.filter((e) => e.isArray).flatMap((e) => {
+		const { fieldName, enumType, enumDetailType, enumDetailsType, enumRows } = e;
+		const getter = code`
         get ${fieldName}(): ${enumType}[] {
-          return ${symbols_1.getField}(this, "${fieldName}") || [];
+          return ${getField}(this, "${fieldName}") || [];
         }
 
         get ${fieldName}Details(): ${enumDetailsType}[] {
           return this.${fieldName}.map(code => ${enumDetailType}.getByCode(code));
         }
      `;
-        const setter = (0, ts_poet_1.code) `
+		const setter = code`
         set ${fieldName}(${fieldName}: ${enumType}[]) {
-          ${symbols_1.setField}(this, "${fieldName}", ${fieldName});
+          ${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) => (0, ts_poet_1.code) `
-          get is${shouldPrefixAccessors ? (0, change_case_1.pascalCase)(fieldName) : ""}${(0, change_case_1.pascalCase)(row.code)}(): boolean {
-            return this.${fieldName}.includes(${enumType}.${(0, change_case_1.pascalCase)(row.code)});
+		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) => code`
+          get is${shouldPrefixAccessors ? pascalCase(fieldName) : ""}${pascalCase(row.code)}(): boolean {
+            return this.${fieldName}.includes(${enumType}.${pascalCase(row.code)});
           }
         `);
-        return [getter, setter, ...accessors];
-    });
+		return [
+			code`${fieldDocBlock(fieldDocs, fieldName, meta.entity.name)}${getter}`,
+			setter,
+			...accessors
+		];
+	});
 }
-function createPgEnums(meta) {
-    return meta.pgEnums.flatMap((e) => {
-        const { fieldName, enumType, enumValues, notNull } = e;
-        const maybeOptional = notNull ? "" : " | undefined";
-        const getter = (0, ts_poet_1.code) `
+function createPgEnums(meta, fieldDocs) {
+	return meta.pgEnums.flatMap((e) => {
+		const { fieldName, enumType, enumValues, notNull } = e;
+		const maybeOptional = notNull ? "" : " | undefined";
+		const getter = code`
         get ${fieldName}(): ${enumType}${maybeOptional} {
-          return ${symbols_1.getField}(this, "${fieldName}");
+          return ${getField}(this, "${fieldName}");
         }
      `;
-        const setter = (0, ts_poet_1.code) `
+		const setter = code`
         set ${fieldName}(${fieldName}: ${enumType}${maybeOptional}) {
-          ${symbols_1.setField}(this, "${fieldName}", ${fieldName});
+          ${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) => (0, ts_poet_1.code) `
-          get is${shouldPrefixAccessors ? (0, change_case_1.pascalCase)(fieldName) : ""}${(0, change_case_1.pascalCase)(row)}(): boolean {
-            return this.${fieldName} === ${enumType}.${(0, change_case_1.pascalCase)(row)};
+		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) => code`
+          get is${shouldPrefixAccessors ? pascalCase(fieldName) : ""}${pascalCase(row)}(): boolean {
+            return this.${fieldName} === ${enumType}.${pascalCase(row)};
           }
         `);
-        return [getter, setter, ...accessors];
-    });
+		return [
+			code`${fieldDocBlock(fieldDocs, fieldName, meta.entity.name)}${getter}`,
+			setter,
+			...accessors
+		];
+	});
 }
 function createRelations(config, meta, entity) {
-    // Add ManyToOne entities
-    const m2o = meta.manyToOnes.map((m2o) => {
-        const { fieldName, otherEntity, otherFieldName, notNull } = m2o;
-        const maybeOptional = notNull ? "never" : "undefined";
-        if (m2o.derived === "async") {
-            const line = (0, ts_poet_1.code) `abstract readonly ${fieldName}: ${symbols_1.ReactiveReference}<${entity.name}, ${otherEntity.type}, ${maybeOptional}>;`;
-            return { kind: "abstract", line };
-        }
-        const decl = (0, ts_poet_1.code) `${symbols_1.ManyToOneReference}<${entity.type}, ${otherEntity.type}, ${maybeOptional}>`;
-        const init = (0, ts_poet_1.code) `${symbols_1.hasOne}()`;
-        return { kind: "concrete", fieldName, decl, init };
-    });
-    // Specialize
-    const m2oBase = meta.baseType?.manyToOnes
-        // Skip m2os that are already specialized to a different otherEntity, i.e. `SmallPublisher.group: SmallPublisherGroup`
-        .filter((m2o) => !meta.manyToOnes.find((o) => o.fieldName === m2o.fieldName))
-        // Don't specialize hasReactiveReferences b/c they're fields, not getters
-        .filter((m2o) => m2o.derived !== "async")
-        .map((m2o) => {
-        const { fieldName, otherEntity, notNull } = m2o;
-        const maybeOptional = notNull ? "never" : "undefined";
-        const decl = (0, ts_poet_1.code) `${symbols_1.ManyToOneReference}<${entity.type}, ${otherEntity.type}, ${maybeOptional}>`;
-        return { kind: "super", fieldName, decl };
-    }) ?? [];
-    // Add any recursive ManyToOne entities
-    const m2oRecursive = meta.manyToOnes
-        .filter((m2o) => m2o.otherEntity.name === meta.name)
-        // Allow disabling recursive relations
-        .filter((m2o) => 
-    // STI subtypes don't have their own key in config.entities (stripped by stripStiPlaceholders),
-    // so look up the base class name to find skipRecursiveRelations config
-    !(config.entities[meta.inheritanceType == "sti" && meta.baseClassName ? meta.baseClassName : meta.name]
-        ?.relations?.[m2o.fieldName]?.skipRecursiveRelations === true))
-        // Skip ReactiveReferences because they don't have an `other` side for us to use
-        .filter((m2o) => !m2o.derived)
-        .flatMap((m2o) => {
-        const { fieldName: m2oName, otherFieldName, otherEntity } = m2o;
-        const parentsField = `${(0, pluralize_1.plural)(m2oName)}Recursive`;
-        const maybeOneToOne = meta.oneToOnes.find((o2o) => o2o.fieldName === otherFieldName);
-        const childrenField = maybeOneToOne ? `${(0, pluralize_1.plural)(otherFieldName)}Recursive` : `${otherFieldName}Recursive`;
-        return [
-            {
-                kind: "concrete",
-                fieldName: parentsField,
-                decl: (0, ts_poet_1.code) `${symbols_1.ReadOnlyCollection}<${entity.type}, ${otherEntity.type}>`,
-                init: (0, ts_poet_1.code) `${symbols_1.hasRecursiveParents}("${m2oName}", "${childrenField}")`,
-            },
-            {
-                kind: "concrete",
-                fieldName: childrenField,
-                decl: (0, ts_poet_1.code) `${symbols_1.ReadOnlyCollection}<${entity.type}, ${otherEntity.type}>`,
-                init: (0, ts_poet_1.code) `${symbols_1.hasRecursiveChildren}("${otherFieldName}", "${parentsField}")`,
-            },
-        ];
-    });
-    // Add any recursive ManyToMany entities (self-referential m2m)
-    const m2mRecursive = meta.manyToManys
-        .filter((m2m) => m2m.otherEntity.name === meta.name)
-        .filter((m2m) => !m2m.derived)
-        // STI subtypes don't have their own key in config.entities (stripped by stripStiPlaceholders),
-        // so look up the base class name to find skipRecursiveRelations config
-        .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: (0, ts_poet_1.code) `${symbols_1.ReadOnlyCollection}<${entity.type}, ${otherEntity.type}>`,
-            init: (0, ts_poet_1.code) `${symbols_1.hasRecursiveM2m}("${fieldName}", "${otherFieldName}Recursive")`,
-        };
-    });
-    // Add OneToMany
-    const o2m = meta.oneToManys.map((o2m) => {
-        const { fieldName, otherEntity } = o2m;
-        const decl = (0, ts_poet_1.code) `${symbols_1.Collection}<${entity.type}, ${otherEntity.type}>`;
-        const init = (0, ts_poet_1.code) `${symbols_1.hasMany}()`;
-        return { kind: "concrete", fieldName, decl, init };
-    });
-    // Specialize
-    const o2mBase = meta.baseType?.oneToManys
-        // Skip o2ms that are already specialized to a different otherEntity, i.e. `SmallPublisherGroup.publishers: SmallPublisher`
-        .filter((o2m) => !meta.oneToManys.find((o) => o.fieldName === o2m.fieldName))
-        .map((o2m) => {
-        const { fieldName, otherEntity } = o2m;
-        const decl = (0, ts_poet_1.code) `${symbols_1.Collection}<${entity.type}, ${otherEntity.type}>`;
-        return { kind: "super", fieldName, decl };
-    }) ?? [];
-    // Add large OneToMany
-    const lo2m = meta.largeOneToManys.map((o2m) => {
-        const { fieldName, otherEntity } = o2m;
-        const decl = (0, ts_poet_1.code) `${symbols_1.LargeCollection}<${entity.type}, ${otherEntity.type}>`;
-        const init = (0, ts_poet_1.code) `${symbols_1.hasLargeMany}()`;
-        return { kind: "concrete", fieldName, decl, init };
-    });
-    // Add OneToOne
-    const o2o = meta.oneToOnes.map((o2o) => {
-        const { fieldName, otherEntity } = o2o;
-        const decl = (0, ts_poet_1.code) `${symbols_1.OneToOneReference}<${entity.type}, ${otherEntity.type}>`;
-        const init = (0, ts_poet_1.code) `${symbols_1.hasOneToOne}()`;
-        return { kind: "concrete", fieldName, decl, init };
-    });
-    // Specialize
-    const o2oBase = meta.baseType?.oneToOnes.map((o2o) => {
-        const { fieldName, otherEntity } = o2o;
-        const decl = (0, ts_poet_1.code) `${symbols_1.OneToOneReference}<${entity.type}, ${otherEntity.type}>`;
-        return { kind: "super", fieldName, decl };
-    }) ?? [];
-    // Add ManyToMany
-    const m2m = meta.manyToManys.map((m2m) => {
-        const { fieldName, otherEntity } = m2m;
-        const comment = `// ${m2m.joinTableName} ${m2m.columnName} ${m2m.otherColumnName}`;
-        if (m2m.derived === "async") {
-            const line = (0, ts_poet_1.code) `abstract readonly ${fieldName}: ${symbols_1.ReactiveManyToMany}<${entity.name}, ${otherEntity.type}>;`;
-            return { kind: "abstract", line, comment };
-        }
-        else if (m2m.derived === "otherSide") {
-            const decl = (0, ts_poet_1.code) `${symbols_1.ReactiveManyToManyOtherSide}<${entity.type}, ${otherEntity.type}>`;
-            const init = (0, ts_poet_1.code) `${symbols_1.hasReactiveManyToManyOtherSide}()`;
-            return { kind: "concrete", fieldName, decl, init, comment };
-        }
-        else if (!m2m.derived) {
-            const decl = (0, ts_poet_1.code) `${symbols_1.Collection}<${entity.type}, ${otherEntity.type}>`;
-            const init = (0, ts_poet_1.code) `${symbols_1.hasManyToMany}()`;
-            return { kind: "concrete", fieldName, decl, init, comment };
-        }
-        else {
-            (0, utils_1.assertNever)(m2m.derived);
-        }
-    });
-    // Specialize
-    const m2mBase = meta.baseType?.manyToManys
-        // Don't specialize hasReactiveManyToMany or hasReactiveManyToManyOtherSide b/c they're fields, not getters
-        .filter((m2m) => !m2m.derived)
-        .map((m2m) => {
-        const { fieldName, otherEntity } = m2m;
-        const decl = (0, ts_poet_1.code) `${symbols_1.Collection}<${entity.type}, ${otherEntity.type}>`;
-        return { kind: "super", fieldName, decl };
-    }) ?? [];
-    // Add enum-backed ManyToMany (i.e. `Publisher.logoColors`)
-    const m2mEnum = meta.manyToManyEnums.map((m2m) => {
-        const { fieldName, enumType } = m2m;
-        const comment = `// ${m2m.joinTableName} ${m2m.columnName} ${m2m.otherColumnName}`;
-        const decl = (0, ts_poet_1.code) `${symbols_1.EnumCollection}<${entity.type}, ${enumType}>`;
-        const init = (0, ts_poet_1.code) `${symbols_1.hasEnumCollection}()`;
-        return { kind: "concrete", fieldName, decl, init, comment };
-    });
-    const m2mEnumBase = meta.baseType?.manyToManyEnums.map((m2m) => {
-        const { fieldName, enumType } = m2m;
-        const decl = (0, ts_poet_1.code) `${symbols_1.EnumCollection}<${entity.type}, ${enumType}>`;
-        return { kind: "super", fieldName, decl };
-    }) ?? [];
-    // Add large ManyToMany
-    const lm2m = meta.largeManyToManys.map((m2m) => {
-        const { joinTableName, fieldName, columnName, otherEntity, otherFieldName, otherColumnName } = m2m;
-        const decl = (0, ts_poet_1.code) `${symbols_1.LargeCollection}<${entity.type}, ${otherEntity.type}>`;
-        const init = (0, ts_poet_1.code) `
-      ${symbols_1.hasLargeManyToMany}(
+	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: code`abstract readonly ${fieldName}: ${ReactiveReference}<${entity.name}, ${otherEntity.type}, ${maybeOptional}>;`
+		};
+		return {
+			kind: "concrete",
+			fieldName,
+			decl: code`${ManyToOneReference}<${entity.type}, ${otherEntity.type}, ${maybeOptional}>`,
+			init: code`${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: code`${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: code`${ReadOnlyCollection}<${entity.type}, ${otherEntity.type}>`,
+			init: code`${hasRecursiveParents}("${m2oName}", "${childrenField}")`
+		}, {
+			kind: "concrete",
+			fieldName: childrenField,
+			decl: code`${ReadOnlyCollection}<${entity.type}, ${otherEntity.type}>`,
+			init: code`${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: code`${ReadOnlyCollection}<${entity.type}, ${otherEntity.type}>`,
+			init: code`${hasRecursiveM2m}("${fieldName}", "${otherFieldName}Recursive")`
+		};
+	});
+	return [
+		meta.oneToManys.map((o2m) => {
+			const { fieldName, otherEntity } = o2m;
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: code`${Collection}<${entity.type}, ${otherEntity.type}>`,
+				init: code`${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: code`${Collection}<${entity.type}, ${otherEntity.type}>`
+			};
+		}) ?? [],
+		meta.largeOneToManys.map((o2m) => {
+			const { fieldName, otherEntity } = o2m;
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: code`${LargeCollection}<${entity.type}, ${otherEntity.type}>`,
+				init: code`${hasLargeMany}()`
+			};
+		}),
+		m2o,
+		m2oBase,
+		m2oRecursive,
+		m2mRecursive,
+		meta.oneToOnes.map((o2o) => {
+			const { fieldName, otherEntity } = o2o;
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: code`${OneToOneReference}<${entity.type}, ${otherEntity.type}>`,
+				init: code`${hasOneToOne}()`
+			};
+		}),
+		meta.baseType?.oneToOnes.map((o2o) => {
+			const { fieldName, otherEntity } = o2o;
+			return {
+				kind: "super",
+				fieldName,
+				decl: code`${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: code`abstract readonly ${fieldName}: ${ReactiveManyToMany}<${entity.name}, ${otherEntity.type}>;`,
+				comment
+			};
+			else if (m2m.derived === "otherSide") return {
+				kind: "concrete",
+				fieldName,
+				decl: code`${ReactiveManyToManyOtherSide}<${entity.type}, ${otherEntity.type}>`,
+				init: code`${hasReactiveManyToManyOtherSide}()`,
+				comment
+			};
+			else if (!m2m.derived) return {
+				kind: "concrete",
+				fieldName,
+				decl: code`${Collection}<${entity.type}, ${otherEntity.type}>`,
+				init: code`${hasManyToMany}()`,
+				comment
+			};
+			else assertNever(m2m.derived);
+		}),
+		meta.baseType?.manyToManys.filter((m2m) => !m2m.derived).map((m2m) => {
+			const { fieldName, otherEntity } = m2m;
+			return {
+				kind: "super",
+				fieldName,
+				decl: code`${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: code`${EnumCollection}<${entity.type}, ${enumType}>`,
+				init: code`${hasEnumCollection}()`,
+				comment
+			};
+		}),
+		meta.baseType?.manyToManyEnums.map((m2m) => {
+			const { fieldName, enumType } = m2m;
+			return {
+				kind: "super",
+				fieldName,
+				decl: code`${EnumCollection}<${entity.type}, ${enumType}>`
+			};
+		}) ?? [],
+		meta.largeManyToManys.map((m2m) => {
+			const { joinTableName, fieldName, columnName, otherEntity, otherFieldName, otherColumnName } = m2m;
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: code`${LargeCollection}<${entity.type}, ${otherEntity.type}>`,
+				init: code`
+      ${hasLargeManyToMany}(
         "${joinTableName}",
         "${columnName}",
         "${otherFieldName}",
         "${otherColumnName}",
         ${m2m.hasJoinTableId},
       );
-    `;
-        return { kind: "concrete", fieldName, decl, init };
-    });
-    // Add Polymorphic
-    const polymorphic = meta.polymorphics.map((p) => {
-        const { fieldName, notNull, fieldType } = p;
-        const maybeOptional = notNull ? "never" : "undefined";
-        const decl = (0, ts_poet_1.code) `${symbols_1.PolymorphicReference}<${entity.type}, ${fieldType}, ${maybeOptional}>`;
-        const init = (0, ts_poet_1.code) `${symbols_1.hasOnePolymorphic}()`;
-        return { kind: "concrete", fieldName, decl, init };
-    });
-    return [
-        o2m,
-        o2mBase,
-        lo2m,
-        m2o,
-        m2oBase,
-        m2oRecursive,
-        m2mRecursive,
-        o2o,
-        o2oBase,
-        m2m,
-        m2mBase,
-        m2mEnum,
-        m2mEnumBase,
-        lm2m,
-        polymorphic,
-    ].flat();
+    `
+			};
+		}),
+		meta.polymorphics.map((p) => {
+			const { fieldName, notNull, fieldType } = p;
+			const maybeOptional = notNull ? "never" : "undefined";
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: code`${PolymorphicReference}<${entity.type}, ${fieldType}, ${maybeOptional}>`,
+				init: code`${hasOnePolymorphic}()`
+			};
+		}),
+		meta.primitives.filter((p) => p.lazy).map((p) => {
+			const { fieldName, fieldType, notNull } = p;
+			const maybeOptional = notNull ? "" : " | undefined";
+			return {
+				kind: "concrete",
+				fieldName,
+				decl: code`${LazyField}<${entity.type}, ${fieldType}${maybeOptional}>`,
+				init: code`${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 ? "?" : "";
+	const hasDefault = field.kind !== "m2o" && field.kind !== "poly" && fieldHasDefaultValue(field) || field.hasConfigDefault;
+	return !field.notNull || hasDefault ? "?" : "";
 }
 function maybeUnionNull(notNull) {
-    return notNull ? "" : " | null";
-}
-function maybeUndefined(notNull) {
-    return notNull ? "" : " | undefined";
+	return notNull ? "" : " | null";
 }
 function undefinedOrNever(notNull) {
-    return notNull ? "never" : "undefined";
+	return notNull ? "never" : "undefined";
 }
 function nullOrNever(notNull) {
-    return notNull ? "never" : "null";
+	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 code`${nowUTC}()`;
+	switch (field.columnType) {
+		case "date": return code`${nowUTC}("plainDate")`;
+		case "timestamp without time zone": return code`${nowUTC}("plainDateTime")`;
+		case "timestamp with time zone": return code`${nowUTC}("zonedDateTime")`;
+		default: return 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` : "";
+	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 ? buildJSDocBlock(`${doc}\n${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 undefined:
-            return "string";
-        case "number":
-            return "number";
-        default:
-            return (0, utils_1.assertNever)(config.idType);
-    }
+	switch (config.idType) {
+		case "untagged-string":
+		case "tagged-string":
+		case void 0: return "string";
+		case "number": return "number";
+		default: return assertNever(config.idType);
+	}
 }
+//#endregion
+export { generateEntityCodegenFile, getIdType };
+
 //# sourceMappingURL=generateEntityCodegenFile.js.map