@rvoh/dream 2.0.4 → 2.1.2

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

@@ -0,0 +1,304 @@
+import ts from 'typescript';
+import { CliFileWriter } from '../../cli/CliFileWriter.js';
+import { DreamConst } from '../../dream/constants.js';
+import compact from '../compact.js';
+import uniq from '../uniq.js';
+import ASTConnectionBuilder from './ASTConnectionBuilder.js';
+import autogeneratedFileDisclaimer from './autoGeneratedFileDisclaimer.js';
+const f = ts.factory;
+/**
+ * Responsible for building dream schema, which can be found at
+ * types/dream.ts. If you are leveraging multiple db connections,
+ * then this file will also be responsible for building all variants,
+ * i.e. types/dream.alternateConnection.ts, etc...
+ *
+ * This class leverages internal AST building mechanisms built into
+ * typescript to manually build up object literals and interfaces
+ * for our app to consume.
+ */
+export default class ASTSchemaBuilder extends ASTConnectionBuilder {
+    /**
+     * builds the new contents for the dream schema file (i.e. types/dream.ts
+     * for default connection), and writes it to the file. This is automatically
+     * done anytime the sync cli command is called, which happens when migrating,
+     * rolling back, and when manually calling the sync command via CLI.
+     */
+    async build() {
+        // build a new, blank source file to populate with our output
+        const sourceFile = ts.createSourceFile('', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+        const { importedTypes, importedVariables, schemaConst, passthroughColumns, allDefaultScopeNames } = await this.buildSchemaConst();
+        const output = await this.prettier(this.printStatements([
+            ...this.dateAndDateTimeImports(),
+            this.dbImports(importedTypes, importedVariables),
+            this.newLine(),
+            schemaConst,
+            this.newLine(),
+            this.buildConnectionTypeConfigConst(passthroughColumns, allDefaultScopeNames),
+        ], sourceFile));
+        await CliFileWriter.write(this.schemaPath(), output);
+    }
+    /**
+     * @internal
+     *
+     * builds up the `export const schema = ...` statement within the dream.ts
+     * file. It does this by leveraging low-level AST utils built into typescript
+     * to manually build up an object literal, cast it as a const, and write it to
+     * an exported variable.
+     */
+    async buildSchemaConst() {
+        const schemaData = await this.getSchemaData();
+        const importedTypes = [];
+        const importedVariables = [];
+        let passthroughColumns = [];
+        let allDefaultScopeNames = [];
+        const dbSourceFile = await this.getDbSourceFile();
+        const schemaObjectLiteral = f.createObjectLiteralExpression(Object.keys(schemaData).map(tableName => {
+            const tableData = schemaData[tableName];
+            allDefaultScopeNames = [...allDefaultScopeNames, ...tableData.scopes.default];
+            return f.createPropertyAssignment(f.createIdentifier(tableName), f.createObjectLiteralExpression([
+                f.createPropertyAssignment(f.createIdentifier('serializerKeys'), f.createArrayLiteralExpression([...(tableData?.serializerKeys || [])].sort().map(key => f.createStringLiteral(key)))),
+                f.createPropertyAssignment(f.createIdentifier('scopes'), f.createObjectLiteralExpression([
+                    f.createPropertyAssignment(f.createIdentifier('default'), f.createArrayLiteralExpression((tableData?.scopes.default).sort().map(key => f.createStringLiteral(key)))),
+                    f.createPropertyAssignment(f.createIdentifier('named'), f.createArrayLiteralExpression((tableData?.scopes.named).sort().map(key => f.createStringLiteral(key)))),
+                ], true // multiline
+                )),
+                f.createPropertyAssignment(f.createIdentifier('nonJsonColumnNames'), f.createArrayLiteralExpression(Object.keys(tableData?.columns || {})
+                    .filter(columnName => !['json', 'jsonb', 'json[]', 'jsonb[]'].includes(tableData.columns[columnName].dbType))
+                    .sort()
+                    .map(key => f.createStringLiteral(key)))),
+                f.createPropertyAssignment(f.createIdentifier('columns'), f.createObjectLiteralExpression(Object.keys(tableData?.columns || {})
+                    .sort()
+                    .map(columnName => {
+                    const columnData = tableData.columns[columnName];
+                    // any enums for these columns will need to be imported
+                    // from the db.ts file in the same folder, so as we detect
+                    // them, we push them into the importedModules array.
+                    if (columnData.enumType) {
+                        importedTypes.push(columnData.enumType);
+                        importedVariables.push(columnData.enumType + 'Values');
+                    }
+                    const enumTypeNode = columnData.enumType
+                        ? f.createTypeReferenceNode(f.createIdentifier(columnData.enumType), undefined // No type arguments needed here
+                        )
+                        : null;
+                    const enumValuesNode = columnData.enumType
+                        ? f.createIdentifier(columnData.enumType + 'Values')
+                        : f.createNull();
+                    const coercedType = this.getCoercedTypeForTableColumn(dbSourceFile, tableName, columnName, tableData, importedTypes);
+                    return f.createPropertyAssignment(f.createIdentifier(columnName), f.createObjectLiteralExpression([
+                        f.createPropertyAssignment(f.createIdentifier('coercedType'), f.createAsExpression(f.createObjectLiteralExpression(), coercedType)),
+                        f.createPropertyAssignment(f.createIdentifier('enumType'), enumTypeNode
+                            ? f.createAsExpression(f.createObjectLiteralExpression(), enumTypeNode)
+                            : f.createNull()),
+                        f.createPropertyAssignment(f.createIdentifier('enumArrayType'), enumTypeNode
+                            ? f.createAsExpression(f.createArrayLiteralExpression(), f.createArrayTypeNode(enumTypeNode))
+                            : f.createNull()),
+                        f.createPropertyAssignment(f.createIdentifier('enumValues'), enumValuesNode),
+                        f.createPropertyAssignment(f.createIdentifier('dbType'), f.createStringLiteral(columnData.dbType)),
+                        f.createPropertyAssignment(f.createIdentifier('allowNull'), columnData.allowNull ? f.createTrue() : f.createFalse()),
+                        f.createPropertyAssignment(f.createIdentifier('isArray'), columnData.isArray ? f.createTrue() : f.createFalse()),
+                    ], true // multiline
+                    ));
+                }), true // multiline
+                )),
+                f.createPropertyAssignment(f.createIdentifier('virtualColumns'), f.createArrayLiteralExpression(tableData?.virtualColumns
+                    ?.sort()
+                    ?.map(columnName => f.createStringLiteral(columnName)))),
+                f.createPropertyAssignment(f.createIdentifier('associations'), f.createObjectLiteralExpression(Object.keys(tableData?.associations || {})
+                    .sort()
+                    .map(associationName => {
+                    const associationMetadata = tableData.associations[associationName];
+                    const andStatement = associationMetadata.and;
+                    const requiredAndClauses = andStatement === null
+                        ? []
+                        : Object.keys(andStatement).filter(column => andStatement[column] === DreamConst.required);
+                    const passthroughAndClauses = andStatement === null
+                        ? []
+                        : Object.keys(andStatement).filter(column => andStatement[column] === DreamConst.passthrough);
+                    passthroughColumns = [...passthroughColumns, ...passthroughAndClauses];
+                    return f.createPropertyAssignment(f.createIdentifier(associationName), f.createObjectLiteralExpression([
+                        f.createPropertyAssignment(f.createIdentifier('type'), f.createStringLiteral(associationMetadata.type)),
+                        f.createPropertyAssignment(f.createIdentifier('foreignKey'), associationMetadata.foreignKey
+                            ? f.createStringLiteral(associationMetadata.foreignKey)
+                            : f.createNull()),
+                        f.createPropertyAssignment(f.createIdentifier('foreignKeyTypeColumn'), associationMetadata.foreignKeyTypeColumn
+                            ? f.createStringLiteral(associationMetadata.foreignKeyTypeColumn)
+                            : f.createNull()),
+                        f.createPropertyAssignment(f.createIdentifier('tables'), f.createArrayLiteralExpression(associationMetadata.tables.sort().map(table => f.createStringLiteral(table)))),
+                        f.createPropertyAssignment(f.createIdentifier('optional'), associationMetadata.optional === null
+                            ? f.createNull()
+                            : associationMetadata.optional
+                                ? f.createTrue()
+                                : f.createFalse()),
+                        f.createPropertyAssignment(f.createIdentifier('requiredAndClauses'), requiredAndClauses.length === 0
+                            ? f.createNull()
+                            : f.createArrayLiteralExpression(requiredAndClauses.sort().map(clause => f.createStringLiteral(clause)))),
+                        f.createPropertyAssignment(f.createIdentifier('passthroughAndClauses'), passthroughAndClauses.length === 0
+                            ? f.createNull()
+                            : f.createArrayLiteralExpression(passthroughAndClauses.sort().map(clause => f.createStringLiteral(clause)))),
+                    ], true // multiline
+                    ));
+                }), true // multiline
+                )),
+            ], true // multiline
+            ));
+        }), true // multiLine
+        );
+        // add "as const" to the end of the schema object we
+        // have built before returning it
+        const constAssertion = f.createAsExpression(schemaObjectLiteral, f.createKeywordTypeNode(ts.SyntaxKind.ConstKeyword));
+        const schemaConst = f.createVariableStatement([f.createModifier(ts.SyntaxKind.ExportKeyword)], f.createVariableDeclarationList([f.createVariableDeclaration(f.createIdentifier('schema'), undefined, undefined, constAssertion)], ts.NodeFlags.Const));
+        return {
+            schemaConst,
+            importedTypes: uniq(importedTypes).sort(),
+            importedVariables: uniq(importedVariables).sort(),
+            passthroughColumns: uniq(passthroughColumns).sort(),
+            allDefaultScopeNames: uniq(allDefaultScopeNames).sort(),
+        };
+    }
+    /**
+     * @internal
+     *
+     * builds up the `export const connectionTypeConfig = ...` statement within the dream.ts
+     * file. It does this by leveraging low-level AST utils built into typescript
+     * to manually build up an object literal, cast it as a const, and write it to
+     * an exported variable.
+     */
+    buildConnectionTypeConfigConst(passthroughColumns, allDefaultScopeNames) {
+        const connectionTypeConfigObjectLiteral = f.createObjectLiteralExpression([
+            f.createPropertyAssignment(f.createIdentifier('passthroughColumns'), f.createArrayLiteralExpression(passthroughColumns.sort().map(column => f.createStringLiteral(column)), true // multiline
+            )),
+            f.createPropertyAssignment(f.createIdentifier('allDefaultScopeNames'), f.createArrayLiteralExpression(allDefaultScopeNames.sort().map(column => f.createStringLiteral(column)), true // multiline
+            )),
+            f.createPropertyAssignment(f.createIdentifier('globalNames'), f.createObjectLiteralExpression([
+                f.createPropertyAssignment(f.createIdentifier('models'), f.createObjectLiteralExpression(this.globalModelNames()
+                    .sort()
+                    .map(([globalName, tableName]) => f.createPropertyAssignment(f.createStringLiteral(globalName), f.createStringLiteral(tableName))), true // multiline
+                )),
+            ], true // multiline
+            )),
+        ], true // multiline
+        );
+        // add "as const" to the end of the schema object we
+        // have built before returning it
+        const constAssertion = f.createAsExpression(connectionTypeConfigObjectLiteral, f.createKeywordTypeNode(ts.SyntaxKind.ConstKeyword));
+        const connectionTypeConfigObjectLiteralConst = f.createVariableStatement([f.createModifier(ts.SyntaxKind.ExportKeyword)], f.createVariableDeclarationList([
+            f.createVariableDeclaration(f.createIdentifier('connectionTypeConfig'), undefined, undefined, constAssertion),
+        ], ts.NodeFlags.Const));
+        return connectionTypeConfigObjectLiteralConst;
+    }
+    /**
+     * @internal
+     *
+     * writes the compiled statements to string. Will also manually inject new lines
+     * into the import statements, since otherwise, they are forced into a single line
+     * and are completely unreadable that way.
+     *
+     * prettier is used in a later step to optimize output, but the user may not have
+     * prettier installed, in which case it will do nothing, and we don't want to leave
+     * the imports unformatted in those cases.
+     */
+    printStatements(statements, sourceFile) {
+        const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed, omitTrailingSemicolon: true });
+        const result = printer.printList(ts.ListFormat.SourceFileStatements, f.createNodeArray(statements), sourceFile);
+        // manually replace single-line db imports with multi-line import
+        const output = result
+            .replace(/import\s*{\s*([^}]+)\s*}\s*from\s*"\.\/db.js"/, (_, names) => {
+            // Split items, trim them, and rejoin with newlines + indentation
+            const formatted = names
+                .split(',')
+                .map((n) => n.trim())
+                .map((n) => `  ${n},`)
+                .join('\n');
+            return `import {\n${formatted}\n} from "./db.js"`;
+        })
+            .replaceAll(/from ([^;]*);/g, 'from $1');
+        return `\
+${autogeneratedFileDisclaimer()}
+${output}`;
+    }
+    /**
+     * @internal
+     *
+     * builds up an AST statement representing the DB imports that the dream.ts
+     * file will need in order to render without import errors. It takes the aggregated
+     * list of imported types and imported variables built up as the schema was being
+     * built, and uses them to build AST import nodes, which can be rendered into the
+     * schema source file.
+     */
+    dbImports(importedTypes, importedVariables) {
+        const namedImports = f.createNamedImports([
+            ...importedTypes.map(importName => f.createImportSpecifier(true, undefined, f.createIdentifier(importName))),
+            ...importedVariables.map(importName => f.createImportSpecifier(false, undefined, f.createIdentifier(importName))),
+        ]);
+        const importClause = f.createImportClause(false, undefined, namedImports);
+        const importDeclaration = f.createImportDeclaration(undefined, importClause, f.createStringLiteral('./db.js'), undefined);
+        return importDeclaration;
+    }
+    /**
+     * @internal
+     *
+     * given a column and table, this method returns the coerced type representation
+     * of whatever type was found in the db.ts file. In most cases, it will simply
+     * return the same type as was found, but in some cases it will perform coercion
+     * to provide consistent and useful types to the underlying application.
+     *
+     * Amongst other things, it will convert Numeric -> number, Int8 -> string, etc...
+     * Timestamp will be carefully converted to either CalendarDate or DateTime, depending
+     * on if the type set in the db is a date or datetime field.
+     */
+    getCoercedTypeForTableColumn(dbSourceFile, tableName, columnName, tableData, importedModules) {
+        const columnData = tableData.columns[columnName];
+        const tableNode = this.getTableInterfaceDeclaration(dbSourceFile, tableName);
+        const propertyNode = this.getPropertyFromInterface(tableNode, columnName);
+        const coercedTypes = this.coercedType(dbSourceFile, propertyNode, columnData.dbType, importedModules);
+        return coercedTypes.length === 1 ? coercedTypes[0] : f.createUnionTypeNode(coercedTypes);
+    }
+    /**
+     * @internal
+     *
+     * used by the getCoercedTypeForTableColumn to get the specific type for a column
+     * if no coercion is necessary, the original type node will be returned
+     */
+    coercedType(dbSourceFile, propertySignature, dbType, importedModules) {
+        const extractedPropertyTypes = this.extractTypeNodesFromTypeOrUnion(propertySignature);
+        const isDate = /^date[[\]]*$/.test(dbType);
+        const types = compact(extractedPropertyTypes.map(typeNode => {
+            const typeText = typeNode.getText(dbSourceFile);
+            let defaultReturnNode = /^Generated/.test(typeText) ? this.getFirstGenericType(typeNode) : typeNode;
+            const modifiedText = defaultReturnNode.getText(dbSourceFile);
+            defaultReturnNode = /^ArrayType/.test(modifiedText)
+                ? f.createArrayTypeNode(this.getFirstGenericType(defaultReturnNode))
+                : defaultReturnNode;
+            const sanitized = typeText
+                .replace(/\s/g, '')
+                .replace(/Generated<(.*)>/g, '$1')
+                .replace(/ArrayType<(.*)>/g, '$1[]');
+            if (sanitized === '')
+                return null;
+            switch (sanitized) {
+                case 'Numeric':
+                    return f.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+                case 'Numeric[]':
+                    return f.createArrayTypeNode(f.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword));
+                case 'Timestamp':
+                    return isDate ? f.createTypeReferenceNode('CalendarDate') : f.createTypeReferenceNode('DateTime');
+                case 'Timestamp[]':
+                    return isDate
+                        ? f.createArrayTypeNode(f.createTypeReferenceNode('CalendarDate'))
+                        : f.createArrayTypeNode(f.createTypeReferenceNode('DateTime'));
+                case 'Int8':
+                    return f.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+                case 'Int8[]':
+                    return f.createArrayTypeNode(f.createKeywordTypeNode(ts.SyntaxKind.StringKeyword));
+                case 'Json':
+                case 'Json[]':
+                    importedModules.push('Json');
+                    return defaultReturnNode;
+                default:
+                    return defaultReturnNode;
+            }
+        }));
+        return types;
+    }
+}

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

@@ -0,0 +1,60 @@
+import * as fsSync from 'node:fs';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import DreamCLI from '../../cli/index.js';
+import DreamApp from '../../dream-app/index.js';
+/**
+ * Originally, psychic-workers tapped into the types produced by psychic,
+ * modifying the psychicTypes to include type configurations for workers
+ * as well. Since Psychic no longer supports this method of augmenting
+ * types, psychic-workers has been refactored to produce its own types
+ * file.
+ *
+ * This service is responsible for identifying applications that are still
+ * reliant on the types produced by psychic, and refactoring them so that their
+ * imports are now in the correct places.
+ */
+export default class DBClassDeprecation {
+    async deprecate() {
+        const dreamApp = DreamApp.getOrFail();
+        if (dreamApp.bypassDeprecationChecks)
+            return;
+        const files = [
+            path.join(process.cwd(), DreamApp.system.dreamPath('models'), 'ApplicationModel.ts'),
+            path.join(process.cwd(), DreamApp.system.dreamPath('models'), 'ApplicationBackgroundedModel.ts'),
+        ];
+        try {
+            for (const file of files) {
+                const exists = fsSync.existsSync(file);
+                if (!exists)
+                    continue;
+                const fileContent = (await fs.readFile(file)).toString();
+                if (fileContent.includes('DBClass')) {
+                    await DreamCLI.logger.logProgress(`[dream] patching deprecated DBClass type for ${file.split(path.sep).at(-1)}`, async () => {
+                        await fs.writeFile(file, fileContent.replace(/DBClass/g, 'DB'));
+                    });
+                }
+            }
+        }
+        catch (err) {
+            console.error(err);
+            console.log(`
+ATTENTION: 
+
+The dream package has formally deprecated the DBClass export from all dream schema files. Any usage
+of the DBClass export throughout your app should be replaced with the "DB" export, which provides an
+identical structure to the original DBClass export.
+
+An automated script is meant to manually catch and fix this for you any time you sync, but for some
+reason it failed. Make sure to replace all DBClass imports throughout your app with the DB export, like so:
+
+import { DB } from '@src/types/db.js'
+
+export default class ApplicationModel extends Dream {
+  declare public DB: DB
+  ...
+}
+`);
+        }
+    }
+}

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

@@ -94,11 +94,12 @@ export function processAttribute(attribute, modelClassName) {
     if (!attributeType) {
         throw new Error(`must pass a column type for ${attributeName} (i.e. ${attributeName}:string)`);
     }
-    switch (attributeType) {
-        case 'belongs_to':
+    const processedAttrType = camelize(attributeType).toLowerCase();
+    switch (processedAttrType) {
+        case 'belongsto':
             return createBelongsToAttribute(attributeName, descriptors, modelClassName);
-        case 'has_one':
-        case 'has_many':
+        case 'hasone':
+        case 'hasmany':
             return { content: '', imports: [] };
         case 'encrypted':
             return createEncryptedAttribute(attributeName, attribute, modelClassName);

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

@@ -30,8 +30,9 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
             continue;
         if (!attributeType)
             throw new Error(`Must pass a column type for ${attributeName} (i.e. ${attributeName}:string)`);
-        switch (attributeType) {
-            case 'belongs_to': {
+        const safeAttributeType = camelize(attributeType)?.toLowerCase();
+        switch (safeAttributeType) {
+            case 'belongsto': {
                 const attributeVariable = camelize(attributeName.split('/').pop());
                 const fullyQualifiedAssociatedModelName = standardizeFullyQualifiedModelName(attributeName);
                 const associationModelName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedAssociatedModelName);

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

@@ -3,6 +3,7 @@ import Query from '../../dream/Query.js';
 import InvalidDecimalFieldPassedToGenerator from '../../errors/InvalidDecimalFieldPassedToGenerator.js';
 import compact from '../compact.js';
 import snakeify from '../snakeify.js';
+import camelize from '../camelize.js';
 const STI_TYPE_COLUMN_NAME = 'type';
 const COLUMNS_TO_INDEX = [STI_TYPE_COLUMN_NAME];
 export default function generateMigrationContent({ connectionName = 'default', table, columnsWithTypes = [], primaryKeyType = 'bigserial', createOrAlter = 'create', stiChildClassName, } = {}) {
@@ -17,11 +18,12 @@ export default function generateMigrationContent({ connectionName = 'default', t
          * email address are the same email address
          */
         const attributeType = nonStandardAttributeName === 'email' ? 'citext' : _attributeType;
+        const processedAttrType = camelize(attributeType)?.toLowerCase();
         const userWantsThisOptional = optionalFromDescriptors(descriptors);
         // when creating a migration for an STI child, we don't want to include notNull;
         // instead, we'll add a check constraint that uses the STI child class name
         const sqlAttributeType = getAttributeType(attributeType, descriptors);
-        if (attributeType === undefined || ['has_one', 'has_many'].includes(attributeType))
+        if (attributeType === undefined || ['hasone', 'hasmany'].includes(processedAttrType))
             return acc;
         if (attributeType === 'citext')
             requireCitextExtension = true;
@@ -30,8 +32,8 @@ export default function generateMigrationContent({ connectionName = 'default', t
         if (nonStandardAttributeName === undefined)
             return acc;
         let attributeName = snakeify(nonStandardAttributeName);
-        switch (attributeType) {
-            case 'belongs_to':
+        switch (processedAttrType) {
+            case 'belongsto':
                 columnDefs.push(generateBelongsToStr(connectionName, attributeName, {
                     primaryKeyType,
                     omitInlineNonNull,
@@ -82,7 +84,7 @@ export default function generateMigrationContent({ connectionName = 'default', t
                 break;
         }
         columnDrops.push(`.dropColumn('${attributeName}')`);
-        if (attributeType === 'belongs_to' || COLUMNS_TO_INDEX.includes(attributeName)) {
+        if (processedAttrType === 'belongsto' || COLUMNS_TO_INDEX.includes(attributeName)) {
             const indexName = `${table}_${attributeName}`;
             indexDefs.push(`await db.schema
     .createIndex('${indexName}')

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

@@ -49,7 +49,7 @@ export default function generateSerializerContent({ fullyQualifiedModelName, col
         const [name, type] = attr.split(':');
         if (name === undefined)
             return '';
-        if (['belongs_to', 'has_one', 'has_many'].includes(type))
+        if (['belongsto', 'hasone', 'hasmany'].includes(camelize(type)?.toLowerCase()))
             return '';
         return `\n    ${attribute(modelClassName, name, type, attr, stiBaseSerializer)}`;
     })

package/dist/types/src/db/helpers/dreamSchemaTypesFilenameForConnection.d.ts

@@ -0,0 +1 @@
+export default function dreamSchemaTypesFilenameForConnection(connectionName: string): string;

package/dist/types/src/dream/QueryDriver/Base.d.ts

@@ -1,12 +1,12 @@
 import { CompiledQuery, DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
 import Dream from '../../Dream.js';
-import { SchemaBuilderAssociationData, SchemaBuilderColumnData } from '../../helpers/cli/SchemaBuilder.js';
 import { AssociationStatement } from '../../types/associations/shared.js';
 import { DbConnectionType } from '../../types/db.js';
 import { DreamColumnNames, DreamConstructorType, DreamTableSchema, PrimaryKeyType } from '../../types/dream.js';
 import { PreloadedDreamsAndWhatTheyPointTo, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../../types/query.js';
 import DreamTransaction from '../DreamTransaction.js';
 import Query from '../Query.js';
+import { SchemaBuilderAssociationData, SchemaBuilderColumnData } from '../../helpers/cli/ASTBuilder.js';
 export default class QueryDriverBase<DreamInstance extends Dream> {
     query: Query<DreamInstance, any>;
     protected readonly dreamClass: DreamConstructorType<DreamInstance>;
@@ -61,7 +61,7 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      *    this file is extremely complex and messy, and will be difficult
      *    to achieve.
      * 2. generate a types/dream.ts file in the same shape as the existing
-     *    one. This is normally done using `await new SchemaBuilder().build()`,
+     *    one. This is normally done using the ASTSchemaBuilder
      *    but this will likely need to be overridden to tailor to your custom
      *    database engine.
      */
@@ -121,7 +121,7 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      */
     static setDatabaseTypeParsers(connectionName: string): Promise<void>;
     static duplicateDatabase(connectionName: string): Promise<void>;
-    static getColumnData(connectionName: string, tableName: string, associationData: {
+    static getColumnData(connectionName: string, tableName: string, allTableAssociationData: {
         [key: string]: SchemaBuilderAssociationData;
     }): Promise<{
         [key: string]: SchemaBuilderColumnData;

package/dist/types/src/dream/QueryDriver/Kysely.d.ts

@@ -1,7 +1,7 @@
 import { DeleteQueryBuilder, Kysely, Transaction as KyselyTransaction, OrderByItemBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
 import { DialectProviderCb } from '../../db/DreamDbConnection.js';
 import Dream from '../../Dream.js';
-import { SchemaBuilderInformationSchemaRow } from '../../helpers/cli/SchemaBuilder.js';
+import { SchemaBuilderInformationSchemaRow } from '../../helpers/cli/ASTBuilder.js';
 import { AssociationStatement } from '../../types/associations/shared.js';
 import { DbConnectionType } from '../../types/db.js';
 import { DreamColumnNames, DreamTableSchema, OrderDir, PrimaryKeyType, SqlCommandType } from '../../types/dream.js';
@@ -37,19 +37,7 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
     /**
      * defines the syncing behavior for dream and psychic,
      * which is run whenever the `sync` command is called.
-     * This is an important step, and will be incredibly
-     * comlpex to override. You will need to do the following
-     * when overriding this method:
-     *
-     * 1. introspect the db and use it to generate a db.ts file in the
-     *    same shape as the existing one. Currently, the process for generating
-     *    this file is extremely complex and messy, and will be difficult
-     *    to achieve.
-     * 2. generate a types/dream.ts file in the same shape as the existing
-     *    one. This is normally done using `await new SchemaBuilder().build()`,
-     *    but this will likely need to be overridden to tailor to your custom
-     *    database engine.
-     */
+     * */
     static sync(connectionName: string, onSync: () => Promise<void> | void, options?: {
         schemaOnly?: boolean;
     }): Promise<void>;

package/dist/types/src/dream/QueryDriver/Postgres.d.ts

@@ -1,5 +1,5 @@
 import Dream from '../../Dream.js';
-import { SchemaBuilderAssociationData, SchemaBuilderColumnData } from '../../helpers/cli/SchemaBuilder.js';
+import { SchemaBuilderAssociationData, SchemaBuilderColumnData } from '../../helpers/cli/ASTBuilder.js';
 import KyselyQueryDriver from './Kysely.js';
 export default class PostgresQueryDriver<DreamInstance extends Dream> extends KyselyQueryDriver<DreamInstance> {
     /**
@@ -27,7 +27,7 @@ export default class PostgresQueryDriver<DreamInstance extends Dream> extends Ky
      * this is used by the SchemaBuilder to store column data permanently
      * within the types/dream.ts file.
      */
-    static getColumnData(connectionName: string, tableName: string, associationData: {
+    static getColumnData(connectionName: string, tableName: string, allTableAssociationData: {
         [key: string]: SchemaBuilderAssociationData;
     }): Promise<{
         [key: string]: SchemaBuilderColumnData;

package/dist/types/src/dream-app/index.d.ts

@@ -4,6 +4,7 @@ import Dream from '../Dream.js';
 import { primaryKeyTypes } from '../dream/constants.js';
 import QueryDriverBase from '../dream/QueryDriver/Base.js';
 import { EncryptOptions } from '../encrypt/index.js';
+import autogeneratedFileDisclaimer from '../helpers/cli/autoGeneratedFileDisclaimer.js';
 import globalClassNameFromFullyQualifiedModelName from '../helpers/globalClassNameFromFullyQualifiedModelName.js';
 import absoluteDreamPath from '../helpers/path/absoluteDreamPath.js';
 import dreamPath from '../helpers/path/dreamPath.js';
@@ -64,6 +65,7 @@ export default class DreamApp {
         inferSerializersFromDreamClassOrViewModelClass: typeof inferSerializersFromDreamClassOrViewModelClass;
         isDreamSerializer: typeof isDreamSerializer;
         serializerNameFromFullyQualifiedModelName: typeof serializerNameFromFullyQualifiedModelName;
+        autogeneratedFileDisclaimer: typeof autogeneratedFileDisclaimer;
     };
     /**
      * @internal
@@ -131,6 +133,14 @@ export default class DreamApp {
     get packageManager(): "yarn" | "npm" | "pnpm";
     private _importExtension;
     get importExtension(): ".js" | ".ts" | "none";
+    /**
+     * if set to true, it will bypass deprecation checks that run
+     * during the sync hook. Defaults to false, we only recommend
+     * overriding this if you are having issues with the deprecation
+     * check.
+     */
+    private _bypassDeprecationChecks;
+    get bypassDeprecationChecks(): boolean;
     protected loadedModels: boolean;
     constructor(opts?: Partial<DreamAppOpts>);
     get models(): Record<string, typeof Dream>;
@@ -143,7 +153,7 @@ export default class DreamApp {
     get parallelDatabasesEnabled(): boolean;
     load<RT extends 'models' | 'serializers'>(resourceType: RT, resourcePath: string, importCb: (path: string) => Promise<any>): Promise<void>;
     plugin(cb: (app: DreamApp) => void | Promise<void>): void;
-    set<ApplyOpt extends DreamAppSetOption>(applyOption: ApplyOpt, options: ApplyOpt extends 'db' ? DreamDbCredentialOptions | string : ApplyOpt extends 'encryption' ? DreamAppEncryptionOptions : ApplyOpt extends 'primaryKeyType' ? (typeof primaryKeyTypes)[number] : ApplyOpt extends 'importExtension' ? GeneratorImportStyle : ApplyOpt extends 'logger' ? DreamLogger : ApplyOpt extends 'projectRoot' ? string : ApplyOpt extends 'inflections' ? () => void | Promise<void> : ApplyOpt extends 'packageManager' ? DreamAppAllowedPackageManagersEnum : ApplyOpt extends 'paths' ? DreamDirectoryPaths : ApplyOpt extends 'parallelTests' ? number : ApplyOpt extends 'unicodeNormalization' ? UnicodeNormalizationForm : ApplyOpt extends 'paginationPageSize' ? number : never, secondaryOptions?: ApplyOpt extends 'db' ? DreamDbCredentialOptions : never): void;
+    set<ApplyOpt extends DreamAppSetOption>(applyOption: ApplyOpt, options: ApplyOpt extends 'bypassDeprecationChecks' ? boolean : ApplyOpt extends 'db' ? DreamDbCredentialOptions | string : ApplyOpt extends 'encryption' ? DreamAppEncryptionOptions : ApplyOpt extends 'primaryKeyType' ? (typeof primaryKeyTypes)[number] : ApplyOpt extends 'importExtension' ? GeneratorImportStyle : ApplyOpt extends 'logger' ? DreamLogger : ApplyOpt extends 'projectRoot' ? string : ApplyOpt extends 'inflections' ? () => void | Promise<void> : ApplyOpt extends 'packageManager' ? DreamAppAllowedPackageManagersEnum : ApplyOpt extends 'paths' ? DreamDirectoryPaths : ApplyOpt extends 'parallelTests' ? number : ApplyOpt extends 'unicodeNormalization' ? UnicodeNormalizationForm : ApplyOpt extends 'paginationPageSize' ? number : never, secondaryOptions?: ApplyOpt extends 'db' ? DreamDbCredentialOptions : never): void;
     on<T extends DreamHookEventType>(hookEventType: T, cb: T extends 'db:log' ? (event: KyselyLogEvent) => void : T extends 'repl:start' ? (context: Context) => void | Promise<void> : never): void;
 }
 export type DreamHookEventType = 'db:log' | 'repl:start';
@@ -156,7 +166,7 @@ export interface DreamAppOpts {
     serializerCasing?: DreamSerializerCasing;
     parallelTests: number | undefined;
 }
-export type DreamAppSetOption = 'db' | 'encryption' | 'inflections' | 'importExtension' | 'logger' | 'paths' | 'primaryKeyType' | 'projectRoot' | 'serializerCasing' | 'parallelTests' | 'unicodeNormalization' | 'paginationPageSize' | 'packageManager';
+export type DreamAppSetOption = 'bypassDeprecationChecks' | 'db' | 'encryption' | 'inflections' | 'importExtension' | 'logger' | 'paths' | 'primaryKeyType' | 'projectRoot' | 'serializerCasing' | 'parallelTests' | 'unicodeNormalization' | 'paginationPageSize' | 'packageManager';
 export interface DreamDirectoryPaths {
     models?: string;
     serializers?: string;