@rvoh/dream 2.6.1-alpha.1 → 2.7.1

package/dist/esm/src/helpers/cli/generateSerializerContent.js

@@ -1,4 +1,3 @@
-import serializerNameFromFullyQualifiedModelName from '../../serializer/helpers/serializerNameFromFullyQualifiedModelName.js';
 import camelize from '../camelize.js';
 import globalClassNameFromFullyQualifiedModelName from '../globalClassNameFromFullyQualifiedModelName.js';
 import absoluteDreamPath from '../path/absoluteDreamPath.js';
@@ -9,9 +8,18 @@ export default function generateSerializerContent({ fullyQualifiedModelName, col
     const additionalImports = [];
     const dreamImports = [];
     const isSTI = !!fullyQualifiedParentName;
+    // Variants that should be emitted in this file. Each variant generates a
+    // matching summary + default serializer pair; STI children import the
+    // corresponding variant from the parent module so the inheritance chain
+    // stays within the same variant (admin → admin, internal → internal).
+    const variantSuffixes = [''];
+    if (includeAdminSerializers)
+        variantSuffixes.push('Admin');
+    if (includeInternalSerializers)
+        variantSuffixes.push('Internal');
     if (isSTI) {
         fullyQualifiedParentName = standardizeFullyQualifiedModelName(fullyQualifiedParentName);
-        additionalImports.push(importStatementForSerializer(fullyQualifiedModelName, fullyQualifiedParentName));
+        additionalImports.push(importStatementForSerializer(fullyQualifiedModelName, fullyQualifiedParentName, variantSuffixes));
     }
     else {
         dreamImports.push('DreamSerializer');
@@ -23,58 +31,50 @@ export default function generateSerializerContent({ fullyQualifiedModelName, col
         : `(${modelInstanceName}: ${modelClassName})`;
     const modelSerializerArgs = `${modelInstanceName}`;
     const dreamSerializerArgs = `${stiBaseSerializer ? `StiChildClass ?? ${modelClassName}` : modelClassName}, ${modelInstanceName}`;
-    const serializerClassName = serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedModelName));
-    const summarySerializerClassName = serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedModelName), 'summary');
-    const defaultSerializerExtends = isSTI
-        ? `${serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedParentName))}(${modelClassName}, ${modelSerializerArgs})`
-        : `${summarySerializerClassName}(${stiBaseSerializer ? 'StiChildClass, ' : ''}${modelSerializerArgs})`;
-    const summarySerializerExtends = isSTI
-        ? `${serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedParentName), 'summary')}(${modelClassName}, ${modelSerializerArgs})`
-        : `DreamSerializer(${dreamSerializerArgs})`;
-    // Admin variants
-    const adminSerializerClassName = serializerClassName.replace(/Serializer$/, 'AdminSerializer');
-    const adminSummarySerializerClassName = summarySerializerClassName.replace(/SummarySerializer$/, 'AdminSummarySerializer');
-    // end:Admin variants
-    // Internal variants
-    const internalSerializerClassName = serializerClassName.replace(/Serializer$/, 'InternalSerializer');
-    const internalSummarySerializerClassName = summarySerializerClassName.replace(/SummarySerializer$/, 'InternalSummarySerializer');
-    // end:Internal variants
+    const localSerializerBase = fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedModelName);
+    const parentSerializerBase = isSTI
+        ? fullyQualifiedModelNameToSerializerBaseName(fullyQualifiedParentName)
+        : '';
     const additionalModelImports = [];
     const dreamImport = dreamImports.length
         ? `import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'\n`
         : '';
     const additionalImportsStr = uniq(additionalImports).join('');
-    const summarySerializer = `export const ${summarySerializerClassName} = ${modelSerializerSignature} =>
-  ${summarySerializerExtends}${isSTI ? '' : `\n    .attribute('id')`}`;
-    const defaultSerializer = `export const ${serializerClassName} = ${modelSerializerSignature} =>
-  ${defaultSerializerExtends}${columnsWithTypes
-        .map(attr => {
-        const [name, type] = attr.split(':');
-        if (name === undefined)
-            return '';
-        if (['belongsto', 'hasone', 'hasmany'].includes(camelize(type)?.toLowerCase()))
-            return '';
-        return `\n    ${attribute(modelClassName, name, type, attr, stiBaseSerializer)}`;
-    })
-        .join('')}`;
+    const buildSerializerPair = (variantSuffix) => {
+        const summaryName = variantSerializerClassName(localSerializerBase, variantSuffix, 'summary');
+        const defaultName = variantSerializerClassName(localSerializerBase, variantSuffix, 'default');
+        const summaryExtends = isSTI
+            ? `${variantSerializerClassName(parentSerializerBase, variantSuffix, 'summary')}(${modelClassName}, ${modelSerializerArgs})`
+            : `DreamSerializer(${dreamSerializerArgs})`;
+        const defaultExtends = isSTI
+            ? `${variantSerializerClassName(parentSerializerBase, variantSuffix, 'default')}(${modelClassName}, ${modelSerializerArgs})`
+            : `${summaryName}(${stiBaseSerializer ? 'StiChildClass, ' : ''}${modelSerializerArgs})`;
+        const summary = `export const ${summaryName} = ${modelSerializerSignature} =>
+  ${summaryExtends}${isSTI ? '' : `\n    .attribute('id')`}`;
+        const defaultBody = columnsWithTypes
+            .map(attr => {
+            const [name, type] = attr.split(':');
+            if (name === undefined)
+                return '';
+            if (['belongsto', 'hasone', 'hasmany'].includes(camelize(type)?.toLowerCase()))
+                return '';
+            return `\n    ${attribute(modelClassName, name, type, attr, stiBaseSerializer)}`;
+        })
+            .join('');
+        const def = `export const ${defaultName} = ${modelSerializerSignature} =>
+  ${defaultExtends}${defaultBody}`;
+        return `${summary}\n\n${def}`;
+    };
+    const serializerBlocks = variantSuffixes.map(buildSerializerPair).join('\n\n');
     return `${dreamImport}${additionalImportsStr}${relatedModelImport}${additionalModelImports.join('')}
-${summarySerializer}
-
-${defaultSerializer}${!includeAdminSerializers
-        ? ''
-        : `
-
-${summarySerializer.replace(summarySerializerClassName, adminSummarySerializerClassName)}
-
-${defaultSerializer.replace(serializerClassName, adminSerializerClassName).replace(summarySerializerClassName, adminSummarySerializerClassName)}`}${!includeInternalSerializers
-        ? ''
-        : `
-
-${summarySerializer.replace(summarySerializerClassName, internalSummarySerializerClassName)}
-
-${defaultSerializer.replace(serializerClassName, internalSerializerClassName).replace(summarySerializerClassName, internalSummarySerializerClassName)}`}
+${serializerBlocks}
 `;
 }
+function variantSerializerClassName(serializerBase, variantSuffix, kind) {
+    return kind === 'summary'
+        ? `${serializerBase}${variantSuffix}SummarySerializer`
+        : `${serializerBase}${variantSuffix}Serializer`;
+}
 function attribute(modelClassName, name, type, attr, stiBaseSerializer) {
     if (name === 'type' && stiBaseSerializer) {
         return `.attribute('type', { openapi: { type: 'string', enum: [(StiChildClass ?? ${modelClassName}).sanitizedName] } })`;
@@ -97,11 +97,14 @@ function attributeOptionsSpecifier(type, attr) {
             return '';
     }
 }
-function importStatementForSerializer(originModelName, destinationModelName) {
-    const defaultSerializer = globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(destinationModelName)));
-    const summarySerializer = globalClassNameFromFullyQualifiedModelName(serializerNameFromFullyQualifiedModelName(fullyQualifiedModelNameToSerializerBaseName(destinationModelName), 'summary'));
+function importStatementForSerializer(originModelName, destinationModelName, variantSuffixes) {
+    const base = fullyQualifiedModelNameToSerializerBaseName(destinationModelName);
+    const names = variantSuffixes.flatMap(suffix => [
+        globalClassNameFromFullyQualifiedModelName(variantSerializerClassName(base, suffix, 'default')),
+        globalClassNameFromFullyQualifiedModelName(variantSerializerClassName(base, suffix, 'summary')),
+    ]);
     const importFrom = absoluteDreamPath('serializers', destinationModelName);
-    return `import { ${defaultSerializer}, ${summarySerializer} } from '${importFrom}'\n`;
+    return `import { ${names.join(', ')} } from '${importFrom}'\n`;
 }
 function importStatementForModel(modelClassName, fullyQualifiedModelName) {
     const importFrom = absoluteDreamPath('models', fullyQualifiedModelName);

package/dist/esm/src/ops/index.js

@@ -5,8 +5,53 @@ import isDatabaseArrayColumn from '../helpers/db/types/isDatabaseArrayColumn.js'
 import CurriedOpsStatement from './curried-ops-statement.js';
 import OpsStatement from './ops-statement.js';
 const ops = {
+    /**
+     * Creates an `OpsStatement` with an arbitrary Kysely comparison operator or trigram operator.
+     * Use this as an escape hatch when none of the named helpers cover your use case.
+     *
+     * @param operator - Any Kysely comparison operator (e.g. `'='`, `'<'`) or trigram operator.
+     * @param value - The value to compare against.
+     * @returns An `OpsStatement` wrapping the given operator and value.
+     *
+     * @example
+     * User.where({ name: ops.expression('like', '%ello%') })
+     */
     expression: (operator, value) => new OpsStatement(operator, value),
+    /**
+     * Creates an `OpsStatement` that checks whether a JSONB column contains the given object
+     * using the PostgreSQL `@>` (contains) operator.
+     *
+     * @param searchObj - A plain object whose key/value pairs must be present in the JSONB column.
+     * @returns An `OpsStatement` using `@> <searchObj>::jsonb`.
+     *
+     * @example
+     * Post.where({ metadata: ops.jsonb({ published: true }) })
+     */
+    jsonb: (searchObj) => new OpsStatement('@>', sql `${searchObj}::jsonb`),
+    /**
+     * Creates an `OpsStatement` for a SQL `IN` clause, matching rows whose column value
+     * is one of the provided array elements.
+     *
+     * @param arr - The array of values to match against.
+     * @returns An `OpsStatement` using the `in` operator.
+     *
+     * @example
+     * User.where({ status: ops.in(['active', 'pending']) })
+     */
     in: (arr) => new OpsStatement('in', arr),
+    /**
+     * Creates a `CurriedOpsStatement` that checks whether a PostgreSQL array column contains
+     * the given value using `@> ARRAY[value]::type`. The column type is resolved at query-build
+     * time from the Dream model's schema.
+     *
+     * Throws `AnyRequiresArrayColumn` if the target column is not a database array type.
+     *
+     * @param value - The scalar value that must be present in the array column.
+     * @returns A `CurriedOpsStatement` that resolves to an `OpsStatement` once bound to a model and field.
+     *
+     * @example
+     * Post.where({ tags: ops.any('typescript') })
+     */
     any: (value) => new CurriedOpsStatement(function (dreamClass, fieldName) {
         const column = fieldName.replace(/^.*\./, '');
         if (!isDatabaseArrayColumn(dreamClass, column))
@@ -14,27 +59,226 @@ const ops = {
         const castType = cachedTypeForAttribute(dreamClass, column);
         return new OpsStatement('@>', sql `ARRAY[${sql.join([value])}]::${sql.raw(castType)}`);
     }),
+    /**
+     * Creates an `OpsStatement` using the SQL `LIKE` operator for case-sensitive pattern matching.
+     * Use `%` as a wildcard in the pattern string.
+     *
+     * @param like - The pattern string (e.g. `'%hello%'`).
+     * @returns An `OpsStatement` using the `like` operator.
+     *
+     * @example
+     * User.where({ name: ops.like('%alice%') })
+     */
     like: (like) => new OpsStatement('like', like),
+    /**
+     * Creates an `OpsStatement` using the SQL `ILIKE` operator for case-insensitive pattern matching.
+     * Use `%` as a wildcard in the pattern string.
+     *
+     * @param ilike - The pattern string (e.g. `'%hello%'`).
+     * @returns An `OpsStatement` using the `ilike` operator.
+     *
+     * @example
+     * User.where({ name: ops.ilike('%alice%') })
+     */
     ilike: (ilike) => new OpsStatement('ilike', ilike),
+    /**
+     * Creates an `OpsStatement` that matches a column against a POSIX regular expression.
+     * By default the match is case-sensitive (`~`); pass `{ caseInsensitive: true }` to use `~*`.
+     *
+     * @param match - The regular expression pattern.
+     * @param options.caseInsensitive - When `true`, uses the `~*` operator instead of `~`. Defaults to `false`.
+     * @returns An `OpsStatement` using `~` or `~*`.
+     *
+     * @example
+     * User.where({ email: ops.match('^admin', { caseInsensitive: true }) })
+     */
     match: (match, { caseInsensitive = false } = {}) => new OpsStatement(caseInsensitive ? '~*' : '~', match),
-    // current
+    /**
+     * Creates an `OpsStatement` using the `=` operator for strict equality.
+     *
+     * @param equal - The value the column must equal.
+     * @returns An `OpsStatement` using the `=` operator.
+     *
+     * @example
+     * User.where({ role: ops.equal('admin') })
+     */
     equal: (equal) => new OpsStatement('=', equal),
+    /**
+     * Creates an `OpsStatement` using the `<` operator.
+     *
+     * @param lessThan - The value the column must be less than.
+     * @returns An `OpsStatement` using the `<` operator.
+     *
+     * @example
+     * Order.where({ total: ops.lessThan(100) })
+     */
     lessThan: (lessThan) => new OpsStatement('<', lessThan),
+    /**
+     * Creates an `OpsStatement` using the `<=` operator.
+     *
+     * @param lessThanOrEqualTo - The value the column must be less than or equal to.
+     * @returns An `OpsStatement` using the `<=` operator.
+     *
+     * @example
+     * Order.where({ total: ops.lessThanOrEqualTo(100) })
+     */
     lessThanOrEqualTo: (lessThanOrEqualTo) => new OpsStatement('<=', lessThanOrEqualTo),
+    /**
+     * Creates an `OpsStatement` using the `>` operator.
+     *
+     * @param greaterThan - The value the column must be greater than.
+     * @returns An `OpsStatement` using the `>` operator.
+     *
+     * @example
+     * Order.where({ total: ops.greaterThan(50) })
+     */
     greaterThan: (greaterThan) => new OpsStatement('>', greaterThan),
+    /**
+     * Creates an `OpsStatement` using the `>=` operator.
+     *
+     * @param greaterThanOrEqualTo - The value the column must be greater than or equal to.
+     * @returns An `OpsStatement` using the `>=` operator.
+     *
+     * @example
+     * Order.where({ total: ops.greaterThanOrEqualTo(50) })
+     */
     greaterThanOrEqualTo: (greaterThanOrEqualTo) => new OpsStatement('>=', greaterThanOrEqualTo),
+    /**
+     * Creates an `OpsStatement` for PostgreSQL trigram similarity (`%` operator).
+     * Rows are included when the similarity score meets or exceeds `score`.
+     *
+     * Requires the `pg_trgm` extension to be enabled.
+     *
+     * @param similarity - The string to compare against the column.
+     * @param options.score - Minimum similarity threshold (0–1). Defaults to `0.3`.
+     * @returns An `OpsStatement` using the `%` trigram operator.
+     *
+     * @example
+     * User.where({ name: ops.similarity('alice', { score: 0.4 }) })
+     */
     similarity: (similarity, { score = 0.3 } = {}) => new OpsStatement('%', similarity, { score }),
+    /**
+     * Creates an `OpsStatement` for PostgreSQL word similarity (`<%` operator).
+     * Rows are included when the word similarity score meets or exceeds `score`.
+     *
+     * Requires the `pg_trgm` extension to be enabled.
+     *
+     * @param similarity - The string to compare against the column.
+     * @param options.score - Minimum word similarity threshold (0–1). Defaults to `0.5`.
+     * @returns An `OpsStatement` using the `<%` trigram operator.
+     *
+     * @example
+     * Article.where({ title: ops.wordSimilarity('postgres', { score: 0.6 }) })
+     */
     wordSimilarity: (similarity, { score = 0.5 } = {}) => new OpsStatement('<%', similarity, { score }),
+    /**
+     * Creates an `OpsStatement` for PostgreSQL strict word similarity (`<<%` operator).
+     * Rows are included when the strict word similarity score meets or exceeds `score`.
+     *
+     * Requires the `pg_trgm` extension to be enabled.
+     *
+     * @param similarity - The string to compare against the column.
+     * @param options.score - Minimum strict word similarity threshold (0–1). Defaults to `0.6`.
+     * @returns An `OpsStatement` using the `<<%` trigram operator.
+     *
+     * @example
+     * Article.where({ title: ops.strictWordSimilarity('postgres', { score: 0.7 }) })
+     */
     strictWordSimilarity: (similarity, { score = 0.6 } = {}) => new OpsStatement('<<%', similarity, { score }),
+    /** Negated variants of the standard comparison operators. */
     not: {
+        /**
+         * Creates an `OpsStatement` for a SQL `NOT IN` clause, excluding rows whose column value
+         * is one of the provided array elements.
+         *
+         * @param arr - The array of values to exclude.
+         * @returns An `OpsStatement` using the `not in` operator.
+         *
+         * @example
+         * User.where({ status: ops.not.in(['banned', 'deleted']) })
+         */
         in: (arr) => new OpsStatement('not in', arr),
+        /**
+         * Creates an `OpsStatement` using the `NOT LIKE` operator for case-sensitive pattern exclusion.
+         *
+         * @param like - The pattern string (e.g. `'%spam%'`).
+         * @returns An `OpsStatement` using the `not like` operator.
+         *
+         * @example
+         * User.where({ email: ops.not.like('%@example.com') })
+         */
         like: (like) => new OpsStatement('not like', like),
+        /**
+         * Creates an `OpsStatement` using the `NOT ILIKE` operator for case-insensitive pattern exclusion.
+         *
+         * @param ilike - The pattern string (e.g. `'%spam%'`).
+         * @returns An `OpsStatement` using the `not ilike` operator.
+         *
+         * @example
+         * User.where({ email: ops.not.ilike('%@example.com') })
+         */
         ilike: (ilike) => new OpsStatement('not ilike', ilike),
+        /**
+         * Creates an `OpsStatement` that excludes rows matching a POSIX regular expression.
+         * By default the match is case-sensitive (`!~`); pass `{ caseInsensitive: true }` to use `!~*`.
+         *
+         * @param match - The regular expression pattern.
+         * @param options.caseInsensitive - When `true`, uses `!~*` instead of `!~`. Defaults to `false`.
+         * @returns An `OpsStatement` using `!~` or `!~*`.
+         *
+         * @example
+         * User.where({ email: ops.not.match('^admin', { caseInsensitive: true }) })
+         */
         match: (match, { caseInsensitive = false } = {}) => new OpsStatement(caseInsensitive ? '!~*' : '!~', match),
+        /**
+         * Creates an `OpsStatement` using the `!=` operator for inequality.
+         *
+         * @param equal - The value the column must not equal.
+         * @returns An `OpsStatement` using the `!=` operator.
+         *
+         * @example
+         * User.where({ role: ops.not.equal('guest') })
+         */
         equal: (equal) => new OpsStatement('!=', equal),
+        /**
+         * Creates an `OpsStatement` that negates `<`, equivalent to `>=`.
+         *
+         * @param lessThan - The value used as the lower bound (inclusive).
+         * @returns An `OpsStatement` using `>=`.
+         *
+         * @example
+         * Order.where({ total: ops.not.lessThan(100) }) // total >= 100
+         */
         lessThan: (lessThan) => new OpsStatement('>=', lessThan),
+        /**
+         * Creates an `OpsStatement` that negates `<=`, equivalent to `>`.
+         *
+         * @param lessThanOrEqualTo - The value used as the lower bound (exclusive).
+         * @returns An `OpsStatement` using `>`.
+         *
+         * @example
+         * Order.where({ total: ops.not.lessThanOrEqualTo(100) }) // total > 100
+         */
         lessThanOrEqualTo: (lessThanOrEqualTo) => new OpsStatement('>', lessThanOrEqualTo),
+        /**
+         * Creates an `OpsStatement` that negates `>`, equivalent to `<=`.
+         *
+         * @param greaterThan - The value used as the upper bound (inclusive).
+         * @returns An `OpsStatement` using `<=`.
+         *
+         * @example
+         * Order.where({ total: ops.not.greaterThan(50) }) // total <= 50
+         */
         greaterThan: (greaterThan) => new OpsStatement('<=', greaterThan),
+        /**
+         * Creates an `OpsStatement` that negates `>=`, equivalent to `<`.
+         *
+         * @param greaterThanOrEqualTo - The value used as the upper bound (exclusive).
+         * @returns An `OpsStatement` using `<`.
+         *
+         * @example
+         * Order.where({ total: ops.not.greaterThanOrEqualTo(50) }) // total < 50
+         */
         greaterThanOrEqualTo: (greaterThanOrEqualTo) => new OpsStatement('<', greaterThanOrEqualTo),
     },
 };

package/dist/types/src/bin/index.d.ts

@@ -17,6 +17,7 @@ export default class DreamBin {
         adminSerializers?: boolean;
         internalSerializers?: boolean;
         modelName?: string;
+        softDelete?: boolean;
     }): Promise<void>;
     static generateStiChild(fullyQualifiedModelName: string, fullyQualifiedParentName: string, columnsWithTypes: string[], options: {
         serializer: boolean;

package/dist/types/src/cli/index.d.ts

@@ -38,6 +38,13 @@ export default class DreamCLI {
              * instead of deriving the class name from the fully qualified model name.
              */
             modelName?: string | undefined;
+            /**
+             * When true (and the generated model is NOT an STI child), decorates
+             * the model with `@SoftDelete()` and auto-emits a nullable
+             * `deleted_at` column. Defaults to false at this programmatic entry
+             * point — the CLI layer opts users in by default.
+             */
+            softDelete?: boolean;
         };
         fullyQualifiedParentName?: string | undefined;
     }): Promise<void>;

package/dist/types/src/helpers/cli/generateDream.d.ts

@@ -6,6 +6,14 @@ export interface GenerateDreamOptions {
     includeInternalSerializers?: boolean;
     tableName?: string | undefined;
     modelName?: string | undefined;
+    /**
+     * When true (and the generated model is NOT an STI child), decorates the
+     * model with `@SoftDelete()` and auto-emits a nullable `deleted_at`
+     * column in the migration and a `deletedAt` field on the model. Defaults
+     * to false at this level — the CLI layer opts users in by default and
+     * allows opt-out via `--no-soft-delete`.
+     */
+    softDelete?: boolean;
 }
 export default function generateDream({ fullyQualifiedModelName, columnsWithTypes, options, fullyQualifiedParentName, }: {
     fullyQualifiedModelName: string;

package/dist/types/src/helpers/cli/generateDreamContent.d.ts

@@ -9,7 +9,15 @@ interface GenerateDreamContentOptions {
     tableName?: string | undefined;
     /** Model class name, computed once via modelClassNameFrom in the orchestrator. */
     modelClassName: string;
+    /**
+     * When true, decorates the generated model with `@SoftDelete()` and adds a
+     * `deletedAt` field to the model. Ignored for STI children (the `@SoftDelete()`
+     * decorator is incompatible with STI children).
+     */
+    softDelete?: boolean;
 }
+export declare function hasExplicitColumn(columnsWithTypes: string[], name: string): boolean;
+export declare function filterAutoGeneratedTimestampColumns(columnsWithTypes: string[]): string[];
 export interface ModelConfig {
     fullyQualifiedModelName: string;
     modelClassName: string;
@@ -29,7 +37,9 @@ export interface AttributeProcessingResult {
 }
 export default function generateDreamContent(options: GenerateDreamContentOptions): string;
 export declare function createModelConfig(options: GenerateDreamContentOptions): ModelConfig;
-export declare function createImportConfig(config: ModelConfig, options: GenerateDreamContentOptions): ImportConfig;
+export declare function createImportConfig(config: ModelConfig, options: GenerateDreamContentOptions, { includeSoftDelete }: {
+    includeSoftDelete: boolean;
+}): ImportConfig;
 export declare function processAttributes(columnsWithTypes: string[], modelClassName: string): AttributeProcessingResult & {
     formattedFields: string;
     formattedDecorators: string;

package/dist/types/src/helpers/cli/generateMigration.d.ts

@@ -1,4 +1,4 @@
-export default function generateMigration({ migrationName, columnsWithTypes, connectionName, fullyQualifiedModelName, fullyQualifiedParentName, tableName: explicitTableName, modelClassName, }: {
+export default function generateMigration({ migrationName, columnsWithTypes, connectionName, fullyQualifiedModelName, fullyQualifiedParentName, tableName: explicitTableName, modelClassName, softDelete, }: {
     migrationName: string;
     columnsWithTypes: string[];
     connectionName: string;
@@ -11,4 +11,10 @@ export default function generateMigration({ migrationName, columnsWithTypes, con
      * Omitted for standalone `g:migration` commands.
      */
     modelClassName?: string | undefined;
+    /**
+     * When true (and not an STI child), the generated `createTable` migration
+     * includes a nullable `deleted_at` column alongside the standard
+     * `created_at` / `updated_at` timestamps.
+     */
+    softDelete?: boolean;
 }): Promise<void>;

package/dist/types/src/helpers/cli/generateMigrationContent.d.ts

@@ -1,10 +1,16 @@
 import { LegacyCompatiblePrimaryKeyType } from '../../types/db.js';
-export default function generateMigrationContent({ connectionName, table, columnsWithTypes, primaryKeyType, createOrAlter, stiChildClassName, }?: {
+export default function generateMigrationContent({ connectionName, table, columnsWithTypes, primaryKeyType, createOrAlter, stiChildClassName, softDelete, }?: {
     connectionName?: string;
     table?: string | undefined;
     columnsWithTypes?: string[] | undefined;
     primaryKeyType?: LegacyCompatiblePrimaryKeyType | undefined;
     createOrAlter?: 'create' | 'alter' | undefined;
     stiChildClassName?: string | undefined;
+    /**
+     * When true (and creating a new table), auto-emits a nullable `deleted_at`
+     * column alongside `created_at` / `updated_at`. Ignored in alter mode and
+     * for STI child migrations.
+     */
+    softDelete?: boolean;
 }): string;
 export declare function optionalFromDescriptors(descriptors: string[]): boolean;