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

package/build/config.js

@@ -1,394 +1,356 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ormMaintainedFields = exports.config = void 0;
-exports.warnInvalidConfigEntries = warnInvalidConfigEntries;
-exports.isGetterField = isGetterField;
-exports.isReactiveField = isReactiveField;
-exports.isReactiveReference = isReactiveReference;
-exports.isReactiveManyToMany = isReactiveManyToMany;
-exports.isProtected = isProtected;
-exports.serdeConfig = serdeConfig;
-exports.superstructConfig = superstructConfig;
-exports.zodSchemaConfig = zodSchemaConfig;
-exports.fieldTypeConfig = fieldTypeConfig;
-exports.isLargeCollection = isLargeCollection;
-exports.isFieldIgnored = isFieldIgnored;
-exports.isFieldHasDefault = isFieldHasDefault;
-exports.loadConfig = loadConfig;
-exports.writeConfig = writeConfig;
-exports.stripStiPlaceholders = stripStiPlaceholders;
-exports.getTimestampConfig = getTimestampConfig;
-const formatter_1 = require("@dprint/formatter");
-const json_1 = require("@dprint/json");
-const fs_1 = require("fs");
-const joist_utils_1 = require("joist-utils");
-const typescript_1 = __importDefault(require("typescript"));
-const zod_1 = require("zod");
-const codemods_1 = require("./codemods");
-const inheritance_1 = require("./inheritance");
-const logger_1 = require("./logger");
-const utils_1 = require("./utils");
-const jsonFormatter = (0, formatter_1.createFromBuffer)((0, fs_1.readFileSync)((0, json_1.getPath)()));
-const fieldConfig = zod_1.z
-    .object({
-    // For getters & ReactiveFields
-    derived: zod_1.z.optional(zod_1.z.union([zod_1.z.literal("sync"), zod_1.z.literal("async")])),
-    protected: zod_1.z.optional(zod_1.z.boolean()),
-    ignore: zod_1.z.optional(zod_1.z.boolean()),
-    superstruct: zod_1.z.optional(zod_1.z.string()),
-    zodSchema: zod_1.z.optional(zod_1.z.string()),
-    type: zod_1.z.optional(zod_1.z.string()),
-    serde: zod_1.z.optional(zod_1.z.string()),
-    stiDiscriminator: zod_1.z.optional(zod_1.z.record(zod_1.z.string(), zod_1.z.string())),
-    stiType: zod_1.z.optional(zod_1.z.string()),
-    // Allow subclasses to mark fields as required
-    notNull: zod_1.z.optional(zod_1.z.boolean()),
-    // Allow overriding scanEntities default detection for fields with defaults added by helpers
-    hasDefault: zod_1.z.optional(zod_1.z.boolean()),
-})
-    .strict();
-const relationConfig = zod_1.z
-    .object({
-    // For ReactiveReferences
-    derived: zod_1.z.optional(zod_1.z.literal("async")),
-    polymorphic: zod_1.z.optional(zod_1.z.union([zod_1.z.literal("notNull"), zod_1.z.literal(true)])),
-    large: zod_1.z.optional(zod_1.z.boolean()),
-    orderBy: zod_1.z.optional(zod_1.z.string()),
-    // Allow pushing m2o/m2m/o2o relations in a base type (Task) down to a subtype (TaskOld)
-    stiType: zod_1.z.optional(zod_1.z.string()),
-    /**
-     * Allow specializing a base type relation (SmallPublisher.group: SmallPublisherGroup).
-     *
-     * Self-referential FKs also support `subType: "self"` that means each subtype will point
-     * at its own subtype.
-     */
-    subType: zod_1.z.optional(zod_1.z.string()),
-    /** Allow skipping self-referential fields getting a `...Recursive` relation. */
-    skipRecursiveRelations: zod_1.z.optional(zod_1.z.boolean()),
-    // Allow marking m2o FKs as required on subclasses
-    notNull: zod_1.z.optional(zod_1.z.boolean()),
-    // Allow overriding scanEntities default detection for fields with defaults added by helpers
-    hasDefault: zod_1.z.optional(zod_1.z.boolean()),
-})
-    .strict();
-const uniqueByConfig = zod_1.z
-    .union([zod_1.z.string(), zod_1.z.array(zod_1.z.string()), zod_1.z.array(zod_1.z.array(zod_1.z.string()))])
-    .transform(normalizeUniqueByConfig);
-const entityConfig = zod_1.z
-    .object({
-    tag: zod_1.z.string(),
-    tableName: zod_1.z.optional(zod_1.z.string()),
-    fields: zod_1.z.optional(zod_1.z.record(zod_1.z.string(), fieldConfig)),
-    relations: zod_1.z.optional(zod_1.z.record(zod_1.z.string(), relationConfig)),
-    /** Whether this entity should be abstract, e.g. for inheritance a subtype must be instantiated instead of this type. */
-    abstract: zod_1.z.optional(zod_1.z.boolean()),
-    orderBy: zod_1.z.optional(zod_1.z.string()),
-    uniqueBy: zod_1.z.optional(uniqueByConfig),
-})
-    .strict();
-const timestampConfig = zod_1.z
-    .object({
-    /** The names to check for this timestamp, i.e. `created_at` `created`, etc. */
-    names: zod_1.z.array(zod_1.z.string()),
-    /** Whether this timestamp column is required to consider a table an entity, defaults to `false`. */
-    required: zod_1.z.optional(zod_1.z.boolean()),
-})
-    .strict();
-exports.config = zod_1.z
-    .object({
-    /** The _build-time_ database URL for reading database metadata. */
-    databaseUrl: zod_1.z.optional(zod_1.z.string()),
-    /** Your application's request-level `Context` type. */
-    contextType: zod_1.z.optional(zod_1.z.string()),
-    /** Your application's database client's `Transaction` type. */
-    transactionType: zod_1.z.optional(zod_1.z.string()),
-    /**
-     * Allows the user to specify the `updated_at` / `created_at` column names to look up, and if they're optional.
-     *
-     * We default to looking for `updated_at`, `updatedAt`, `created_at`, `createdAt`, and optional to true,
-     * e.g. tables are not required to have both timestamp columns to be considered entities.
-     *
-     * These defaults are the most lenient, to facilitate running Joist against an existing schema and
-     * seeing all of your entities, regardless of your previous conventions.
-     */
-    timestampColumns: zod_1.z.optional(zod_1.z.object({
-        createdAt: zod_1.z.optional(timestampConfig),
-        updatedAt: zod_1.z.optional(timestampConfig),
-        deletedAt: zod_1.z.optional(timestampConfig),
-    })),
-    /**
-     * Allows the user to have codegen output `Temporal` types instead of the base JS `Date`
-     *
-     * Additionally, allows for specifying the default time zone for `Temporal` types when converting dates to/from
-     * the database.
-     */
-    temporal: zod_1.z.optional(zod_1.z.union([zod_1.z.boolean(), zod_1.z.object({ timeZone: zod_1.z.string() })])),
-    /**
-     * By default, we create a `flush_database` function for fast testing.
-     *
-     * However, if you don't want to use this, or you have your own bespoke function like we do
-     * that is more application-aware, then you can disable Joist's out-of-the-box one.
-     *
-     * If you have more than one test database, you can set `createFlushFunction` to the array
-     * of test database names, i.e. `mydb_test_1`, `mydb_test_2`, etc.
-     */
-    createFlushFunction: zod_1.z.optional(zod_1.z.union([zod_1.z.boolean(), zod_1.z.array(zod_1.z.string())])),
-    entitiesDirectory: zod_1.z.string().default("./src/entities"),
-    codegenPlugins: zod_1.z.optional(zod_1.z.array(zod_1.z.string())),
-    entities: zod_1.z.record(zod_1.z.string(), entityConfig).default({}),
-    ignoredTables: zod_1.z.optional(zod_1.z.array(zod_1.z.string())),
-    /** The type of entity `id` fields; defaults to `tagged-string`. */
-    idType: zod_1.z.optional(zod_1.z.union([zod_1.z.literal("tagged-string"), zod_1.z.literal("untagged-string"), zod_1.z.literal("number")])),
-    /** How we should support non-deferred foreign keys. */
-    nonDeferredForeignKeys: zod_1.z.optional(zod_1.z.union([zod_1.z.literal("error"), zod_1.z.literal("warn"), zod_1.z.literal("ignore")])),
-    /** Enables esm output. */
-    esm: zod_1.z.optional(zod_1.z.boolean()),
-    /** Controls the style of GraphQL pagination scaffolding. */
-    paginationStyle: zod_1.z.optional(zod_1.z.union([zod_1.z.literal("cursor"), zod_1.z.literal("limit")])).default("cursor"),
-    /** Enables documentation syncing between .md files and JSDocs. */
-    docs: zod_1.z.optional(zod_1.z.boolean()),
-    /** Output a metadata-docs.ts file with entity/field documentation available at runtime. */
-    outputDocs: zod_1.z.optional(zod_1.z.boolean()),
-    /** Auto-set by probing the project's `tsconfig.json` file. */
-    allowImportingTsExtensions: zod_1.z.optional(zod_1.z.boolean()),
-    /** The latest Joist codemod counter that has been applied to this project. */
-    codemodVersion: zod_1.z.number().int().min(0).default(0),
-    /** A list of postgres schemas to use for finding tables */
-    schemas: zod_1.z.optional(zod_1.z.array(zod_1.z.string())),
-})
-    .strict();
-exports.ormMaintainedFields = ["createdAt", "updatedAt"];
+import { getLatestCodemodVersion } from "./codemods/index.js";
+import { fail, sortKeys, trueIfResolved } from "./utils.js";
+import { getStiEntities } from "./inheritance.js";
+import { logger } from "./logger.js";
+import "./EntityDbMetadata.js";
+import { groupBy } from "joist-utils";
+import { existsSync, promises, readFileSync } from "fs";
+import { dirname, join } from "path";
+import { createFromBuffer } from "@dprint/formatter";
+import { getPath } from "@dprint/json";
+import { parse } from "jsonc-parser";
+import { z } from "zod";
+//#region src/config.ts
+const jsonFormatter = createFromBuffer(readFileSync(getPath()));
+const fieldConfig = z.object({
+	derived: z.optional(z.union([z.literal("sync"), z.literal("async")])),
+	protected: z.optional(z.boolean()),
+	ignore: z.optional(z.boolean()),
+	superstruct: z.optional(z.string()),
+	zodSchema: z.optional(z.string()),
+	type: z.optional(z.string()),
+	serde: z.optional(z.string()),
+	stiDiscriminator: z.optional(z.record(z.string(), z.string())),
+	stiType: z.optional(z.union([z.string(), z.array(z.string())])),
+	notNull: z.optional(z.boolean()),
+	hasDefault: z.optional(z.boolean()),
+	lazy: z.optional(z.boolean())
+}).strict();
+const relationConfig = z.object({
+	derived: z.optional(z.literal("async")),
+	polymorphic: z.optional(z.union([z.literal("notNull"), z.literal(true)])),
+	large: z.optional(z.boolean()),
+	orderBy: z.optional(z.string()),
+	/**
+	* Controls whether this collection's `.get`/`.load` hide soft-deleted entities.
+	*
+	* Defaults to `"exclude"` (soft-deleted entities are hidden); set to `"include"` to have
+	* this specific o2m/m2m always return soft-deleted entities from `.get`/`.load`.
+	*/
+	softDeletes: z.optional(z.union([z.literal("include"), z.literal("exclude")])),
+	stiType: z.optional(z.union([z.string(), z.array(z.string())])),
+	/**
+	* Allow specializing a base type relation (SmallPublisher.group: SmallPublisherGroup).
+	*
+	* Self-referential FKs also support `subType: "self"` that means each subtype will point
+	* at its own subtype.
+	*/
+	subType: z.optional(z.string()),
+	/** Allow skipping self-referential fields getting a `...Recursive` relation. */
+	skipRecursiveRelations: z.optional(z.boolean()),
+	notNull: z.optional(z.boolean()),
+	hasDefault: z.optional(z.boolean())
+}).strict();
+const uniqueByConfig = z.union([
+	z.string(),
+	z.array(z.string()),
+	z.array(z.array(z.string()))
+]).transform(normalizeUniqueByConfig);
+const entityConfig = z.object({
+	tag: z.string(),
+	tableName: z.optional(z.string()),
+	fields: z.optional(z.record(z.string(), fieldConfig)),
+	relations: z.optional(z.record(z.string(), relationConfig)),
+	/** Whether this entity should be abstract, e.g. for inheritance a subtype must be instantiated instead of this type. */
+	abstract: z.optional(z.boolean()),
+	orderBy: z.optional(z.string()),
+	uniqueBy: z.optional(uniqueByConfig)
+}).strict();
+const timestampConfig = z.object({
+	/** The names to check for this timestamp, i.e. `created_at` `created`, etc. */
+	names: z.array(z.string()),
+	/** Whether this timestamp column is required to consider a table an entity, defaults to `false`. */
+	required: z.optional(z.boolean())
+}).strict();
+const config = z.object({
+	/** The _build-time_ database URL for reading database metadata. */
+	databaseUrl: z.optional(z.string()),
+	/** Your application's request-level `Context` type. */
+	contextType: z.optional(z.string()),
+	/** Your application's database client's `Transaction` type. */
+	transactionType: z.optional(z.string()),
+	/**
+	* Allows the user to specify the `updated_at` / `created_at` column names to look up, and if they're optional.
+	*
+	* We default to looking for `updated_at`, `updatedAt`, `created_at`, `createdAt`, and optional to true,
+	* e.g. tables are not required to have both timestamp columns to be considered entities.
+	*
+	* These defaults are the most lenient, to facilitate running Joist against an existing schema and
+	* seeing all of your entities, regardless of your previous conventions.
+	*/
+	timestampColumns: z.optional(z.object({
+		createdAt: z.optional(timestampConfig),
+		updatedAt: z.optional(timestampConfig),
+		deletedAt: z.optional(timestampConfig)
+	})),
+	/**
+	* Allows the user to have codegen output `Temporal` types instead of the base JS `Date`
+	*
+	* Additionally, allows for specifying the default time zone for `Temporal` types when converting dates to/from
+	* the database.
+	*/
+	temporal: z.optional(z.union([z.boolean(), z.object({ timeZone: z.string() })])),
+	/**
+	* By default, we create a `flush_database` function for fast testing.
+	*
+	* However, if you don't want to use this, or you have your own bespoke function like we do
+	* that is more application-aware, then you can disable Joist's out-of-the-box one.
+	*
+	* If you have more than one test database, you can set `createFlushFunction` to the array
+	* of test database names, i.e. `mydb_test_1`, `mydb_test_2`, etc.
+	*/
+	createFlushFunction: z.optional(z.union([z.boolean(), z.array(z.string())])),
+	entitiesDirectory: z.string().default("./src/entities"),
+	codegenPlugins: z.optional(z.array(z.string())),
+	entities: z.record(z.string(), entityConfig).default({}),
+	ignoredTables: z.optional(z.array(z.string())),
+	/** The type of entity `id` fields; defaults to `tagged-string`. */
+	idType: z.optional(z.union([
+		z.literal("tagged-string"),
+		z.literal("untagged-string"),
+		z.literal("number")
+	])),
+	/** The separator between entity tags and ids; defaults to `:`, and `""` disables the separator. */
+	tagDelimiter: z.optional(z.string()),
+	/** How we should support non-deferred foreign keys. */
+	nonDeferredForeignKeys: z.optional(z.union([
+		z.literal("error"),
+		z.literal("warn"),
+		z.literal("ignore")
+	])),
+	/** Enables esm output. */
+	esm: z.optional(z.boolean()),
+	/** Controls the style of GraphQL pagination scaffolding. */
+	paginationStyle: z.optional(z.union([z.literal("cursor"), z.literal("limit")])).default("cursor"),
+	/** Enables documentation syncing between .md files and JSDocs. */
+	docs: z.optional(z.boolean()),
+	/** Installs Joist's bundled Agent Skills into `.claude/skills` and `.agents/skills`; on by default, set `false` to disable. */
+	skills: z.optional(z.boolean()),
+	/** Output a metadata-docs.ts file with entity/field documentation available at runtime. */
+	outputDocs: z.optional(z.boolean()),
+	/** Auto-set by probing the project's `tsconfig.json` file. */
+	allowImportingTsExtensions: z.optional(z.boolean()),
+	/** The latest Joist codemod counter that has been applied to this project. */
+	codemodVersion: z.number().int().min(0).default(0),
+	/** A list of postgres schemas to use for finding tables */
+	schemas: z.optional(z.array(z.string()))
+}).strict();
+const ormMaintainedFields = ["createdAt", "updatedAt"];
 /** Ensure the user doesn't have any typos in their config. */
 function warnInvalidConfigEntries(config, db) {
-    const entitiesByName = (0, joist_utils_1.groupBy)(db.entities, (e) => e.name);
-    for (const [entityName, entityConfig] of Object.entries(config.entities)) {
-        const entities = entitiesByName[entityName];
-        if (!entities) {
-            logger_1.logger.warn(`Found config for non-existent entity ${entityName}`);
-            continue;
-        }
-        // We don't have keyBy...
-        const [entity] = entities;
-        // Check fields
-        const fields = [...entity.primitives, ...entity.enums];
-        for (const [name, config] of Object.entries(entityConfig.fields || {})) {
-            if (config.ignore)
-                continue;
-            let field = fields.find((f) => f.fieldName === name);
-            // STI types might be in the base type
-            if (!field && entity.stiDiscriminatorField) {
-                const stiEntities = (0, inheritance_1.getStiEntities)(db.entities).get(entity.name)?.subTypes;
-                field = stiEntities?.flatMap((st) => [...st.primitives, ...st.enums]).find((f) => f.fieldName === name);
-            }
-            if (!field)
-                logger_1.logger.warn(`Found config for non-existent field ${entityName}.${name}`);
-        }
-        // Check relations
-        const relations = [
-            ...entity.manyToOnes,
-            ...entity.oneToManys,
-            ...entity.manyToManys,
-            ...entity.manyToManyEnums,
-            ...entity.oneToOnes,
-            ...entity.largeOneToManys,
-            ...entity.largeManyToManys,
-            ...entity.polymorphics,
-        ];
-        for (const [name, _] of Object.entries(entityConfig.relations || {})) {
-            let relation = relations.find((r) => r.fieldName === name);
-            // STI types might be in the subtypes
-            if (!relation && entity.stiDiscriminatorField) {
-                const stiEntities = (0, inheritance_1.getStiEntities)(db.entities).get(entity.name)?.subTypes;
-                relation = stiEntities
-                    ?.flatMap((entity) => [
-                    ...entity.manyToOnes,
-                    ...entity.oneToManys,
-                    ...entity.manyToManys,
-                    ...entity.oneToOnes,
-                    ...entity.largeOneToManys,
-                    ...entity.largeManyToManys,
-                    ...entity.polymorphics,
-                ])
-                    ?.find((f) => f.fieldName === name);
-            }
-            // CTI subtype specializations (i.e. SmallPublisher.group: SmallPublisherGroup) need to look in the base type
-            if (!relation && entity.baseType) {
-                const baseType = entity.baseType;
-                relation = [
-                    ...baseType.manyToOnes,
-                    ...baseType.oneToManys,
-                    ...baseType.manyToManys,
-                    ...baseType.oneToOnes,
-                    ...baseType.largeOneToManys,
-                    ...baseType.largeManyToManys,
-                    ...baseType.polymorphics,
-                ].find((f) => f.fieldName === name);
-            }
-            if (!relation)
-                logger_1.logger.warn(`Found config for non-existent relation ${entityName}.${name}`);
-        }
-        const uniqueFields = [
-            ...entity.primitives,
-            ...entity.enums,
-            ...entity.pgEnums,
-            ...entity.manyToOnes,
-            ...entity.polymorphics,
-        ];
-        for (const uniqueBy of entityConfig.uniqueBy || []) {
-            for (const name of uniqueBy) {
-                const field = uniqueFields.find((f) => f.fieldName === name);
-                if (!field) {
-                    logger_1.logger.warn(`Found uniqueBy for non-existent or non-queryable field ${entityName}.${name}`);
-                }
-                else if (field.kind === "primitive" && (field.derived || field.isArray || field.customSerde)) {
-                    logger_1.logger.warn(`Found uniqueBy for unsupported primitive field ${entityName}.${name}`);
-                }
-                else if (field.kind === "enum" && (field.derived || field.isArray)) {
-                    logger_1.logger.warn(`Found uniqueBy for unsupported enum field ${entityName}.${name}`);
-                }
-            }
-        }
-    }
+	const entitiesByName = groupBy(db.entities, (e) => e.name);
+	for (const [entityName, entityConfig] of Object.entries(config.entities)) {
+		const entities = entitiesByName[entityName];
+		if (!entities) {
+			logger.warn(`Found config for non-existent entity ${entityName}`);
+			continue;
+		}
+		const [entity] = entities;
+		const fields = [...entity.primitives, ...entity.enums];
+		for (const [name, config] of Object.entries(entityConfig.fields || {})) {
+			if (config.ignore) continue;
+			let field = fields.find((f) => f.fieldName === name);
+			if (!field && entity.stiDiscriminatorField) field = (getStiEntities(db.entities).get(entity.name)?.subTypes)?.flatMap((st) => [...st.primitives, ...st.enums]).find((f) => f.fieldName === name);
+			if (!field) logger.warn(`Found config for non-existent field ${entityName}.${name}`);
+		}
+		const relations = [
+			...entity.manyToOnes,
+			...entity.oneToManys,
+			...entity.manyToManys,
+			...entity.manyToManyEnums,
+			...entity.oneToOnes,
+			...entity.largeOneToManys,
+			...entity.largeManyToManys,
+			...entity.polymorphics
+		];
+		for (const [name, _] of Object.entries(entityConfig.relations || {})) {
+			let relation = relations.find((r) => r.fieldName === name);
+			if (!relation && entity.stiDiscriminatorField) relation = (getStiEntities(db.entities).get(entity.name)?.subTypes)?.flatMap((entity) => [
+				...entity.manyToOnes,
+				...entity.oneToManys,
+				...entity.manyToManys,
+				...entity.oneToOnes,
+				...entity.largeOneToManys,
+				...entity.largeManyToManys,
+				...entity.polymorphics
+			])?.find((f) => f.fieldName === name);
+			if (!relation && entity.baseType) {
+				const baseType = entity.baseType;
+				relation = [
+					...baseType.manyToOnes,
+					...baseType.oneToManys,
+					...baseType.manyToManys,
+					...baseType.oneToOnes,
+					...baseType.largeOneToManys,
+					...baseType.largeManyToManys,
+					...baseType.polymorphics
+				].find((f) => f.fieldName === name);
+			}
+			if (!relation) logger.warn(`Found config for non-existent relation ${entityName}.${name}`);
+		}
+		const uniqueFields = [
+			...entity.primitives,
+			...entity.enums,
+			...entity.pgEnums,
+			...entity.manyToOnes,
+			...entity.polymorphics
+		];
+		for (const uniqueBy of entityConfig.uniqueBy || []) for (const name of uniqueBy) {
+			const field = uniqueFields.find((f) => f.fieldName === name);
+			if (!field) logger.warn(`Found uniqueBy for non-existent or non-queryable field ${entityName}.${name}`);
+			else if (field.kind === "primitive" && (field.derived || field.isArray || field.customSerde)) logger.warn(`Found uniqueBy for unsupported primitive field ${entityName}.${name}`);
+			else if (field.kind === "enum" && (field.derived || field.isArray)) logger.warn(`Found uniqueBy for unsupported enum field ${entityName}.${name}`);
+		}
+	}
 }
 function isGetterField(config, entity, fieldName) {
-    return config.entities[entity.name]?.fields?.[fieldName]?.derived === "sync";
+	return config.entities[entity.name]?.fields?.[fieldName]?.derived === "sync";
 }
 function isReactiveField(config, entity, fieldName) {
-    return config.entities[entity.name]?.fields?.[fieldName]?.derived === "async";
+	return config.entities[entity.name]?.fields?.[fieldName]?.derived === "async";
 }
 function isReactiveReference(config, entity, fieldName) {
-    return config.entities[entity.name]?.relations?.[fieldName]?.derived === "async";
+	return config.entities[entity.name]?.relations?.[fieldName]?.derived === "async";
 }
 /** Returns true if this m2m relation is configured as a ReactiveManyToMany (derived: async). */
 function isReactiveManyToMany(config, entity, fieldName) {
-    return config.entities[entity.name]?.relations?.[fieldName]?.derived === "async";
+	return config.entities[entity.name]?.relations?.[fieldName]?.derived === "async";
 }
 function isProtected(config, entity, fieldName) {
-    return config.entities[entity.name]?.fields?.[fieldName]?.protected === true;
+	return config.entities[entity.name]?.fields?.[fieldName]?.protected === true;
+}
+/** Whether a column should be excluded from the default SELECT and exposed as a lazy-loaded `LazyField`. */
+function isLazyField(config, entity, fieldName) {
+	return config.entities[entity.name]?.fields?.[fieldName]?.lazy === true;
 }
 function serdeConfig(config, entity, fieldName) {
-    return config.entities[entity.name]?.fields?.[fieldName]?.serde;
+	return config.entities[entity.name]?.fields?.[fieldName]?.serde;
 }
 function superstructConfig(config, entity, fieldName) {
-    return config.entities[entity.name]?.fields?.[fieldName]?.superstruct;
+	return config.entities[entity.name]?.fields?.[fieldName]?.superstruct;
 }
 function zodSchemaConfig(config, entity, fieldName) {
-    return config.entities[entity.name]?.fields?.[fieldName]?.zodSchema;
+	return config.entities[entity.name]?.fields?.[fieldName]?.zodSchema;
 }
 function fieldTypeConfig(config, entity, fieldName) {
-    return config.entities[entity.name]?.fields?.[fieldName]?.type;
+	return config.entities[entity.name]?.fields?.[fieldName]?.type;
 }
 function isLargeCollection(config, entity, fieldName) {
-    return config.entities[entity.name]?.relations?.[fieldName]?.large === true;
+	return config.entities[entity.name]?.relations?.[fieldName]?.large === true;
+}
+/** Whether a collection should include (or exclude) soft-deleted entities from `.get`/`.load`. */
+function softDeletesConfig(config, entity, fieldName) {
+	return config.entities[entity.name]?.relations?.[fieldName]?.softDeletes;
 }
 function isFieldIgnored(config, entity, fieldName, notNull = false, hasDefault = false) {
-    const ignore = config.entities[entity.name]?.fields?.[fieldName]?.ignore === true;
-    if (ignore && notNull && !hasDefault) {
-        (0, utils_1.fail)(`notNull field ${entity.name}.${fieldName} cannot be ignored. Alter the column to be optional or have a default value prior to ignoring it.`);
-    }
-    return ignore;
+	const ignore = config.entities[entity.name]?.fields?.[fieldName]?.ignore === true;
+	if (ignore && notNull && !hasDefault) fail(`notNull field ${entity.name}.${fieldName} cannot be ignored. Alter the column to be optional or have a default value prior to ignoring it.`);
+	return ignore;
 }
 function isFieldHasDefault(config, entity, fieldName) {
-    const entityConfig = config.entities[entity.name] ?? {};
-    const fieldConfig = entityConfig.fields?.[fieldName] ?? entityConfig.relations?.[fieldName] ?? {};
-    return fieldConfig.hasDefault === true;
+	const entityConfig = config.entities[entity.name] ?? {};
+	return (entityConfig.fields?.[fieldName] ?? entityConfig.relations?.[fieldName] ?? {}).hasDefault === true;
 }
 const configPath = "./joist-config.json";
 async function loadConfig() {
-    const exists = await (0, utils_1.trueIfResolved)(fs_1.promises.access(configPath));
-    if (exists) {
-        const content = await fs_1.promises.readFile(configPath);
-        const result = exports.config.safeParse(stripLegacyConfigKeys(JSON.parse(content.toString())));
-        if (!result.success) {
-            throw new Error(`Invalid joist-config.json: ${result.error.issues
-                .map((ze) => `${ze.path.map(String).join("/")} ${ze.message}`)
-                .join("\n")}`);
-        }
-        result.data.allowImportingTsExtensions ??= projectIsUsingEsmWithImports();
-        return result.data;
-    }
-    // Brand-new projects should not be prompted to run historical codemods.
-    const initial = exports.config.parse({ codemodVersion: (0, codemods_1.getLatestCodemodVersion)() });
-    initial.allowImportingTsExtensions ??= projectIsUsingEsmWithImports();
-    return initial;
+	if (await trueIfResolved(promises.access(configPath))) {
+		const content = await promises.readFile(configPath);
+		const result = config.safeParse(stripLegacyConfigKeys(JSON.parse(content.toString())));
+		if (!result.success) throw new Error(`Invalid joist-config.json: ${result.error.issues.map((ze) => `${ze.path.map(String).join("/")} ${ze.message}`).join("\n")}`);
+		result.data.allowImportingTsExtensions ??= projectIsUsingEsmWithImports();
+		return result.data;
+	}
+	const initial = config.parse({ codemodVersion: getLatestCodemodVersion() });
+	initial.allowImportingTsExtensions ??= projectIsUsingEsmWithImports();
+	return initial;
 }
 /**
- * Writes the potentially-updated config entry back to `joist-config.json`.
- *
- * We format the output with prettier so it should both a) look nice and b) be deterministic,
- * such that no changes to the config show up as noops to the scm.
- */
+* Writes the potentially-updated config entry back to `joist-config.json`.
+*
+* We format the output with prettier so it should both a) look nice and b) be deterministic,
+* such that no changes to the config show up as noops to the scm.
+*/
 async function writeConfig(config) {
-    const sorted = (0, utils_1.sortKeys)(config);
-    delete sorted.__tableToEntityName;
-    delete sorted.allowImportingTsExtensions;
-    if (sorted.paginationStyle === "cursor") {
-        delete sorted.paginationStyle;
-    }
-    const input = JSON.stringify(sorted);
-    const content = jsonFormatter.formatText({ filePath: "test.json", fileText: input });
-    await fs_1.promises.writeFile(configPath, content);
+	const sorted = sortKeys(config);
+	delete sorted.__tableToEntityName;
+	delete sorted.allowImportingTsExtensions;
+	if (sorted.paginationStyle === "cursor") delete sorted.paginationStyle;
+	const input = JSON.stringify(sorted);
+	const content = jsonFormatter.formatText({
+		filePath: "test.json",
+		fileText: input
+	});
+	await promises.writeFile(configPath, content);
 }
 function stripStiPlaceholders(config, entities) {
-    // Defacto (with today's setup) the config of STI entities lives on the base entity,
-    // so don't write confusing subtype-specific entries into the config file.
-    // ...hopefully we don't have any code accidentally looking for the STI config...
-    for (const entity of entities) {
-        if (entity.inheritanceType === "sti" && entity.stiDiscriminatorValue) {
-            delete config.entities[entity.name];
-        }
-    }
+	for (const entity of entities) if (entity.inheritanceType === "sti" && entity.stiDiscriminatorValue) delete config.entities[entity.name];
 }
 /** Applies defaults to the timestamp config. */
 function getTimestampConfig(config) {
-    return {
-        createdAtConf: {
-            names: ["created_at", "createdAt"],
-            required: false,
-            ...config?.timestampColumns?.createdAt,
-        },
-        updatedAtConf: {
-            names: ["updated_at", "updatedAt"],
-            required: false,
-            ...config?.timestampColumns?.updatedAt,
-        },
-        deletedAtConf: {
-            names: ["deleted_at", "deletedAt"],
-            required: false,
-            ...config?.timestampColumns?.deletedAt,
-        },
-    };
+	return {
+		createdAtConf: {
+			names: ["created_at", "createdAt"],
+			required: false,
+			...config?.timestampColumns?.createdAt
+		},
+		updatedAtConf: {
+			names: ["updated_at", "updatedAt"],
+			required: false,
+			...config?.timestampColumns?.updatedAt
+		},
+		deletedAtConf: {
+			names: ["deleted_at", "deletedAt"],
+			required: false,
+			...config?.timestampColumns?.deletedAt
+		}
+	};
 }
 function projectIsUsingEsmWithImports() {
-    // Attempt to find the project's tsconfig.json in the current directory or up the directory hierarchy
-    const configPath = typescript_1.default.findConfigFile("./", typescript_1.default.sys.fileExists, "tsconfig.json");
-    if (!configPath) {
-        return false;
-    }
-    const configFile = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
-    if (configFile.error) {
-        return false;
-    }
-    return configFile.config?.compilerOptions?.allowImportingTsExtensions === true;
+	const configPath = findTsConfigFile(process.cwd());
+	if (!configPath) return false;
+	try {
+		const errors = [];
+		const parsed = parse(readFileSync(configPath, "utf8"), errors, { allowTrailingComma: true });
+		if (errors.length > 0 || typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return false;
+		const compilerOptions = parsed.compilerOptions;
+		return typeof compilerOptions === "object" && compilerOptions !== null && !Array.isArray(compilerOptions) && compilerOptions.allowImportingTsExtensions === true;
+	} catch {
+		return false;
+	}
 }
 /** Normalizes `uniqueBy` config sugar into runtime identity candidates. */
 function normalizeUniqueByConfig(uniqueBy) {
-    if (typeof uniqueBy === "string")
-        return [[uniqueBy]];
-    if (uniqueBy.every((field) => typeof field === "string"))
-        return [uniqueBy];
-    return uniqueBy;
+	if (typeof uniqueBy === "string") return [[uniqueBy]];
+	if (uniqueBy.every((field) => typeof field === "string")) return [uniqueBy];
+	return uniqueBy;
 }
 function stripLegacyConfigKeys(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-        return raw;
-    }
-    // Accept old configs so the deprecated key disappears on the next write.
-    const parsed = { ...raw };
-    delete parsed.version;
-    return parsed;
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+	const parsed = { ...raw };
+	delete parsed.version;
+	return parsed;
+}
+/** Finds the nearest `tsconfig.json` in `directory` or one of its ancestors. */
+function findTsConfigFile(directory) {
+	while (true) {
+		const fileName = join(directory, "tsconfig.json");
+		if (existsSync(fileName)) return fileName;
+		const parent = dirname(directory);
+		if (parent === directory) return void 0;
+		directory = parent;
+	}
 }
+//#endregion
+export { config, fieldTypeConfig, getTimestampConfig, isFieldHasDefault, isFieldIgnored, isGetterField, isLargeCollection, isLazyField, isProtected, isReactiveField, isReactiveManyToMany, isReactiveReference, loadConfig, ormMaintainedFields, serdeConfig, softDeletesConfig, stripStiPlaceholders, superstructConfig, warnInvalidConfigEntries, writeConfig, zodSchemaConfig };
+
 //# sourceMappingURL=config.js.map