@rvoh/dream 2.0.4 → 2.1.0

package/dist/cjs/src/bin/index.js

@@ -1,6 +1,7 @@
 import DreamCLI from '../cli/index.js';
 import DreamApp from '../dream-app/index.js';
 import Query from '../dream/Query.js';
+import DBClassDeprecation from '../helpers/cli/DBClassDeprecation.js';
 import generateDream from '../helpers/cli/generateDream.js';
 import sspawn from '../helpers/sspawn.js';
 export default class DreamBin {
@@ -9,6 +10,7 @@ export default class DreamBin {
         for (const connectionName of Object.keys(dreamApp.dbCredentials)) {
             await Query.dbDriverClass(connectionName).sync(connectionName, onSync, options);
         }
+        await new DBClassDeprecation().deprecate();
     }
     static async dbCreate() {
         const dreamApp = DreamApp.getOrFail();

package/dist/cjs/src/db/helpers/dreamSchemaTypesFilenameForConnection.js

@@ -0,0 +1,3 @@
+export default function dreamSchemaTypesFilenameForConnection(connectionName) {
+    return connectionName === 'default' ? 'dream.ts' : `dream.${connectionName}.ts`;
+}

package/dist/cjs/src/db/helpers/syncDbTypesFiles.js

@@ -1,14 +1,10 @@
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { CliFileWriter } from '../../cli/CliFileWriter.js';
 import DreamCLI from '../../cli/index.js';
 import colorize from '../../cli/logger/loggable/colorize.js';
 import DreamApp from '../../dream-app/index.js';
-import autogeneratedFileDisclaimer from '../../helpers/cli/autoGeneratedFileDisclaimer.js';
-import compact from '../../helpers/compact.js';
-import EnvInternal from '../../helpers/EnvInternal.js';
+import ASTKyselyCodegenEnhancer from '../../helpers/cli/ASTKyselyCodegenEnhancer.js';
 import dreamPath from '../../helpers/path/dreamPath.js';
-import snakeify from '../../helpers/snakeify.js';
 import sspawn from '../../helpers/sspawn.js';
 import dbTypesFilenameForConnection from './dbTypesFilenameForConnection.js';
 export default async function syncDbTypesFiles(connectionName) {
@@ -26,88 +22,5 @@ export default async function syncDbTypesFiles(connectionName) {
             });
         },
     });
-    // intentionally bypassing helpers here, since they often end up referencing
-    // from the dist folder, whereas dirname here is pointing to true src folder.
-    const file = (await fs.readFile(absoluteDbSyncPath)).toString();
-    const enhancedSchema = enhanceSchema(file);
-    await CliFileWriter.write(absoluteDbSyncPath, enhancedSchema);
-}
-// begin: schema helpers
-function enhanceSchema(file) {
-    file = removeUnwantedExports(file);
-    file = replaceInt8Type(file);
-    file = replaceJsonType(file);
-    const interfaces = file.split(/export interface /g);
-    const results = interfaces.slice(1, interfaces.length);
-    const dbInterface = results.find(str => /^DB \{/.test(str));
-    const camelDbInterface = camelcasify(dbInterface);
-    file = camelcasify(file);
-    file = file.replace(camelDbInterface, dbInterface);
-    file = addCustomImports(file);
-    const transformedNames = compact(results.map(result => transformName(result)));
-    const fileWithCoercedTypes = exportedEnumTypesToExportedTypeValues(file);
-    // BEGIN FILE CONTENTS BUILDING
-    const newFileContents = `${fileWithCoercedTypes}
-
-export class DBClass {
-  ${transformedNames
-        .map(name => `${snakeify(name)}: ${name}`)
-        .sort()
-        .join('\n  ')}
-}
-`;
-    const sortedFileContents = alphaSortInterfaceProperties(newFileContents);
-    return sortedFileContents;
-}
-function removeUnwantedExports(file) {
-    return file.replace(/\nexport type Timestamp = ColumnType<.*/, `export type Timestamp = ColumnType<DateTime | CalendarDate>`);
-}
-function addCustomImports(file) {
-    const customImports = EnvInternal.boolean('DREAM_CORE_DEVELOPMENT')
-        ? "import type CalendarDate from '../../src/helpers/CalendarDate.js'\nimport { type DateTime } from '../../src/helpers/DateTime.js'"
-        : "import { type CalendarDate, type DateTime } from '@rvoh/dream'";
-    return `${autogeneratedFileDisclaimer()}${customImports}
-${file}`;
-}
-function replaceInt8Type(str) {
-    return str.replace('export type Int8 = ColumnType<string, bigint | number | string>', 'export type Int8 = ColumnType<string, bigint | number | string, bigint | number | string>');
-}
-function replaceJsonType(str) {
-    return str.replace('export type Json = ColumnType<JsonValue, string, string>', 'export type Json = ColumnType<JsonValue, string | JsonValue, string | JsonValue>');
-}
-function camelcasify(str) {
-    return _camelcasify(str);
-}
-function _camelcasify(str) {
-    const camelString = str.replace(/([( .])([a-z][a-zA-Z0-9]*)_([a-z0-9])([a-z0-9]*)/g, (match, p1, p2, p3, p4) => `${p1}${p2}${p3.toUpperCase()}${p4}`);
-    return camelString === str ? camelString : _camelcasify(camelString);
-}
-function alphaSortInterfaceProperties(str) {
-    return str.replace(/(export interface [^\n{]+){\n([^}]+)\n}/g, (_match, interfaceDeclaration, lines) => {
-        const props = lines.split(/\n/);
-        return `${interfaceDeclaration}{
-${props.sort().join('\n')}
-}`;
-    });
-}
-function exportedEnumTypesToExportedTypeValues(str) {
-    const ommitedTypes = ['Generated<T>', 'Json', 'JsonArray', 'JsonObject', 'JsonPrimitive', 'JsonValue'];
-    return str.replace(/export type ([^=]*) = ((?!ColumnType)[^;\n]*);/g, (_match, typeDeclaration, types) => {
-        const originalType = `export type ${typeDeclaration} = ${types};`;
-        if (ommitedTypes.some(type => type === typeDeclaration)) {
-            return originalType;
-        }
-        return `\
-${originalType}
-export const ${typeDeclaration}Values = [
-  ${types.split(' | ').join(',\n  ')}
-] as const
-`;
-    });
-}
-function transformName(str) {
-    const name = str.split(' {')[0]?.replace(/\s/g, '');
-    if (name === undefined || name === 'DB')
-        return null;
-    return name;
+    await new ASTKyselyCodegenEnhancer(connectionName).enhance();
 }

package/dist/cjs/src/dream/QueryDriver/Base.js

@@ -90,7 +90,7 @@ export default class QueryDriverBase {
      *    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.
      */
@@ -172,7 +172,7 @@ export default class QueryDriverBase {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     tableName, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    associationData) {
+    allTableAssociationData) {
         throw new Error('implement getColumnData in child class');
     }
     static serializeDbType(type, val) {

package/dist/cjs/src/dream/QueryDriver/Kysely.js

@@ -34,8 +34,9 @@ import NotNullViolation from '../../errors/db/NotNullViolation.js';
 import UnexpectedUndefined from '../../errors/UnexpectedUndefined.js';
 import CalendarDate from '../../helpers/CalendarDate.js';
 import camelize from '../../helpers/camelize.js';
+import ASTGlobalSchemaBuilder from '../../helpers/cli/ASTGlobalSchemaBuilder.js';
+import ASTSchemaBuilder from '../../helpers/cli/ASTSchemaBuilder.js';
 import generateMigration from '../../helpers/cli/generateMigration.js';
-import SchemaBuilder from '../../helpers/cli/SchemaBuilder.js';
 import compact from '../../helpers/compact.js';
 import { DateTime } from '../../helpers/DateTime.js';
 import EnvInternal from '../../helpers/EnvInternal.js';
@@ -158,31 +159,20 @@ export default class KyselyQueryDriver extends QueryDriverBase {
     /**
      * 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 async sync(connectionName, onSync, options = {}) {
         try {
             if (!options?.schemaOnly) {
                 await DreamCLI.logger.logProgress(`introspecting db for connection: ${connectionName}...`, async () => {
+                    // this calls kysely-codegen under the hood
                     await syncDbTypesFiles(connectionName);
                 });
             }
-            const schemaBuilder = new SchemaBuilder(connectionName);
+            const newSchemaBuilder = new ASTSchemaBuilder(connectionName);
             await DreamCLI.logger.logProgress(`building dream schema for connection ${connectionName}...`, async () => {
-                await schemaBuilder.build();
+                await newSchemaBuilder.build();
             });
-            if (schemaBuilder.hasForeignKeyError && !options?.schemaOnly) {
+            if (newSchemaBuilder.hasForeignKeyError && !options?.schemaOnly) {
                 await DreamCLI.logger.logProgress('triggering resync to correct for foreign key errors...', async () => {
                     // TODO: make this customizable to enable dream apps to separate
                     const cliCmd = EnvInternal.boolean('DREAM_CORE_DEVELOPMENT') ? 'dream' : 'psy';
@@ -196,7 +186,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
                     });
                 });
             }
-            await SchemaBuilder.buildGlobalTypes();
+            await new ASTGlobalSchemaBuilder().build();
             if (!options?.schemaOnly) {
                 // intentionally leaving logs off here, since it allows other
                 // onSync handlers to determine their own independent logging approach
@@ -205,7 +195,7 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         }
         catch (error) {
             console.error(error);
-            await DreamCLI.logger.logProgress('sync failed, reverting file contents...', async () => {
+            await DreamCLI.logger.logProgress('[dream] sync failed, reverting file contents...', async () => {
                 await CliFileWriter.revert();
             });
         }

package/dist/cjs/src/dream/QueryDriver/Postgres.js

@@ -111,7 +111,7 @@ export default class PostgresQueryDriver extends KyselyQueryDriver {
      * this is used by the SchemaBuilder to store column data permanently
      * within the types/dream.ts file.
      */
-    static async getColumnData(connectionName, tableName, associationData) {
+    static async getColumnData(connectionName, tableName, allTableAssociationData) {
         const db = this.dbFor(connectionName, 'primary');
         const sqlQuery = sql `SELECT column_name, udt_name::regtype, is_nullable, data_type FROM information_schema.columns WHERE table_name = ${tableName}`;
         const columnToDBTypeMap = await sqlQuery.execute(db);
@@ -120,7 +120,7 @@ export default class PostgresQueryDriver extends KyselyQueryDriver {
         rows.forEach(row => {
             const isEnum = ['USER-DEFINED', 'ARRAY'].includes(row.dataType) && !isPrimitiveDataType(row.udtName);
             const isArray = ['ARRAY'].includes(row.dataType);
-            const associationMetadata = associationData[row.columnName];
+            const associationMetadata = allTableAssociationData[row.columnName];
             columnData[camelize(row.columnName)] = {
                 dbType: row.udtName,
                 allowNull: row.isNullable === 'YES',

package/dist/cjs/src/dream-app/index.js

@@ -6,6 +6,7 @@ import Encrypt from '../encrypt/index.js';
 import DreamAppInitMissingCallToLoadModels from '../errors/dream-app/DreamAppInitMissingCallToLoadModels.js';
 import DreamAppInitMissingMissingProjectRoot from '../errors/dream-app/DreamAppInitMissingMissingProjectRoot.js';
 import CalendarDate from '../helpers/CalendarDate.js';
+import autogeneratedFileDisclaimer from '../helpers/cli/autoGeneratedFileDisclaimer.js';
 import { DateTime, Settings } from '../helpers/DateTime.js';
 import EnvInternal from '../helpers/EnvInternal.js';
 import globalClassNameFromFullyQualifiedModelName from '../helpers/globalClassNameFromFullyQualifiedModelName.js';
@@ -92,6 +93,7 @@ export default class DreamApp {
             inferSerializersFromDreamClassOrViewModelClass,
             isDreamSerializer,
             serializerNameFromFullyQualifiedModelName,
+            autogeneratedFileDisclaimer,
         };
     }
     /**
@@ -233,6 +235,16 @@ Try setting it to something valid, like:
     get importExtension() {
         return this._importExtension;
     }
+    /**
+     * 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.
+     */
+    _bypassDeprecationChecks = false;
+    get bypassDeprecationChecks() {
+        return this._bypassDeprecationChecks;
+    }
     loadedModels = false;
     constructor(opts) {
         if (opts?.db)
@@ -317,6 +329,9 @@ Try setting it to something valid, like:
     }
     set(applyOption, options, secondaryOptions) {
         switch (applyOption) {
+            case 'bypassDeprecationChecks':
+                this._bypassDeprecationChecks = options;
+                break;
             case 'db':
                 if (typeof options === 'string') {
                     this._dbCredentials[options] = secondaryOptions;

package/dist/cjs/src/helpers/cli/ASTBuilder.js

@@ -0,0 +1,277 @@
+import * as path from 'node:path';
+import ts from 'typescript';
+import DreamApp from '../../dream-app/index.js';
+import EnvInternal from '../EnvInternal.js';
+const f = ts.factory;
+/**
+ * @internal
+ *
+ * This is a base class, which is inherited by the ASTSchemaBuilder,
+ * the ASTKyselyCodegenEnhancer, and the ASTGlobalSchemaBuilder,
+ * each of which is responsible for building up the output of the various
+ * type files consumed by dream internally.
+ *
+ * This base class is just a container for common methods used by all
+ * classes.
+ */
+export default class ASTBuilder {
+    /**
+     * @internal
+     *
+     * builds a new line, useful for injecting new lines into AST statements
+     */
+    newLine() {
+        return f.createIdentifier('\n');
+    }
+    /**
+     * @internal
+     *
+     * given an interface declaration, it will extrace the relevant property statement
+     * by the given property name.
+     */
+    getPropertyFromInterface(interfaceNode, propertyName) {
+        for (const member of interfaceNode.members) {
+            if (ts.isPropertySignature(member)) {
+                if (ts.isIdentifier(member.name) && member.name.text === propertyName) {
+                    return member;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * @internal
+     *
+     * returns an array of string type literals which were extracted from
+     * either a type or type union, depending on what is provided
+     * for the typeAlias. this allows you to safely and easily collect
+     * an array of types given an alias
+     */
+    extractStringLiteralTypeNodesFromTypeOrUnion(typeAlias) {
+        const literals = [];
+        if (ts.isUnionTypeNode(typeAlias.type)) {
+            typeAlias.type.types.forEach(typeNode => {
+                if (ts.isLiteralTypeNode(typeNode) && ts.isStringLiteral(typeNode.literal)) {
+                    literals.push(typeNode);
+                }
+            });
+        }
+        else if (ts.isLiteralTypeNode(typeAlias.type) && ts.isStringLiteral(typeAlias.type.literal)) {
+            literals.push(typeAlias.type);
+        }
+        return literals;
+    }
+    /**
+     * @internal
+     *
+     * returns an array of type literals which were extracted from
+     * either a type or type union, depending on what is provided
+     * for the typeAlias. this allows you to safely and easily collect
+     * an array of types given an alias
+     */
+    extractTypeNodesFromTypeOrUnion(typeAlias) {
+        const literals = [];
+        if (typeAlias.type && ts.isUnionTypeNode(typeAlias.type)) {
+            typeAlias.type.types.forEach(typeNode => {
+                literals.push(typeNode);
+            });
+        }
+        else if (typeAlias.type) {
+            literals.push(typeAlias.type);
+        }
+        return literals;
+    }
+    /**
+     * @internal
+     *
+     * returns the provided node iff
+     *   a.) the node is an exported type alias
+     *   b.) the exported name matches the provided name (or else there was no name provided)
+     *
+     *  otherwise, returns null
+     */
+    exportedTypeAliasOrNull(node, exportName) {
+        if (ts.isTypeAliasDeclaration(node) &&
+            node?.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            (!exportName ? true : node.name.text === exportName))
+            return node;
+        return null;
+    }
+    /**
+     * @internal
+     *
+     * returns the provided node iff
+     *   a.) the node is an exported interface
+     *   b.) the exported name matches the provided name (or else there was no name provided)
+     *
+     *  otherwise, returns null
+     */
+    exportedInterfaceOrNull(node, exportName) {
+        if (ts.isInterfaceDeclaration(node) &&
+            node?.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) &&
+            (!exportName ? true : node.name.text === exportName))
+            return node;
+        return null;
+    }
+    /**
+     * @internal
+     *
+     * extracts the exportName from the provided dbSourceFile
+     */
+    findDbExport(dbSourceFile, exportName) {
+        let foundNode;
+        ts.forEachChild(dbSourceFile, node => {
+            const hasModifiers = ts.isFunctionDeclaration(node) ||
+                ts.isClassDeclaration(node) ||
+                ts.isInterfaceDeclaration(node) ||
+                ts.isVariableStatement(node) ||
+                ts.isTypeAliasDeclaration(node);
+            if (hasModifiers) {
+                const isExported = node.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword);
+                if (isExported && ts.isVariableStatement(node)) {
+                    const declarations = node.declarationList.declarations;
+                    const name = declarations?.[0]?.name;
+                    if (declarations.length > 0 && ts.isIdentifier(name) && name?.text === exportName) {
+                        foundNode = node;
+                        return true; // Stop traversal
+                    }
+                }
+                const declarationWithName = node;
+                if (isExported &&
+                    declarationWithName.name &&
+                    ts.isIdentifier(declarationWithName.name) &&
+                    declarationWithName.name.text === exportName) {
+                    foundNode = node;
+                    return true; // Stop traversal
+                }
+            }
+        });
+        return foundNode;
+    }
+    /**
+     * @internal
+     *
+     * returns the path to the dream.globals.ts file
+     */
+    globalSchemaPath() {
+        const dreamApp = DreamApp.getOrFail();
+        return path.join(dreamApp.projectRoot, dreamApp.paths.types, 'dream.globals.ts');
+    }
+    /**
+     * @internal
+     *
+     * safely runs prettier against the provided output. If prettier
+     * is not installed, then the original output is returned
+     */
+    async prettier(output) {
+        try {
+            // dynamically, safely bring in prettier.
+            // ini the event that it fails, we will return the
+            // original output, unformatted, since prettier
+            // is technically not a real dependency of dream,
+            // though psychic and dream apps are provisioned
+            // with prettier by default, so this should usually work
+            const prettier = (await import('prettier')).default;
+            const results = await prettier.format(output, {
+                parser: 'typescript',
+                semi: false,
+                singleQuote: true,
+                tabWidth: 2,
+                lineWidth: 80,
+            });
+            return typeof results === 'string' ? results : output;
+        }
+        catch {
+            // intentional noop, we don't want to raise if prettier
+            // fails, since it is possible for the end user to not
+            // want to use prettier, and it is not a required peer
+            // dependency of dream
+            return output;
+        }
+    }
+    /**
+     * @internal
+     *
+     * given a type node, it will send back the first found generic
+     * provided to that type.
+     */
+    getFirstGenericType(node) {
+        if (ts.isTypeReferenceNode(node)) {
+            if (node.typeArguments && node.typeArguments.length > 0) {
+                return node.typeArguments[0];
+            }
+        }
+        else if (ts.isCallExpression(node)) {
+            if (node.typeArguments && node.typeArguments.length > 0) {
+                return node.typeArguments[0];
+            }
+        }
+        return null;
+    }
+    /**
+     * @internal
+     *
+     * returns the DateTime and CalendarDate imports. This is fairly
+     * tricky, since it considers whether or not we are in the dream
+     * internals (i.e. when testing dream). If we are, it will return
+     * valid internal import paths to those files. Otherwise, it will
+     * import them both from @rvoh/dream.
+     */
+    dateAndDateTimeImports() {
+        if (EnvInternal.boolean('DREAM_CORE_DEVELOPMENT')) {
+            const calendarImport = ts.factory.createImportClause(true, f.createIdentifier('CalendarDate'), undefined);
+            const calendarImportDeclaration = ts.factory.createImportDeclaration(undefined, calendarImport, ts.factory.createStringLiteral('../../src/helpers/CalendarDate.js'));
+            const dateTimeNamedImports = ts.factory.createNamedImports([
+                f.createImportSpecifier(true, undefined, ts.factory.createIdentifier('DateTime')),
+            ]);
+            const dateTimeImportClause = ts.factory.createImportClause(false, // isTypeOnly: false for the clause itself if not all imports are type only
+            undefined, // name: undefined for default import
+            dateTimeNamedImports // namedBindings
+            );
+            const dateTimeImportDeclaration = ts.factory.createImportDeclaration(undefined, dateTimeImportClause, ts.factory.createStringLiteral('../../src/helpers/DateTime.js'));
+            return [calendarImportDeclaration, dateTimeImportDeclaration];
+        }
+        else {
+            const namedImports = ts.factory.createNamedImports(['CalendarDate', 'DateTime'].map(importName => f.createImportSpecifier(true, undefined, ts.factory.createIdentifier(importName))));
+            const importClause = ts.factory.createImportClause(false, // isTypeOnly: false for the clause itself if not all imports are type only
+            undefined, // name: undefined for default import
+            namedImports // namedBindings
+            );
+            const importDeclaration = ts.factory.createImportDeclaration(undefined, // modifiers: e.g., 'export' or 'declare'
+            importClause, ts.factory.createStringLiteral('@rvoh/dream'));
+            return [importDeclaration];
+        }
+    }
+    /**
+     * @internal
+     *
+     * for a given table name (i.e. balloon_lines), it will return the exported
+     * `BalloonLines` interface within the dbSourceFile
+     */
+    getTableInterfaceDeclaration(dbSourceFile, tableName) {
+        const DB = this.findDbExport(dbSourceFile, 'DB');
+        let targetProperty = null;
+        for (const member of DB.members) {
+            if (ts.isPropertySignature(member) && member.name.getText(dbSourceFile) === tableName) {
+                targetProperty = member;
+                break;
+            }
+        }
+        const tableInterfaceName = (targetProperty?.type)
+            .typeName?.escapedText;
+        if (!tableInterfaceName)
+            throw new Error(`failed to find table interface for table: ${tableName}`);
+        const tableInterface = this.findDbExport(dbSourceFile, tableInterfaceName);
+        return tableInterface;
+    }
+    /**
+     * @internal
+     *
+     * returns an array of global names for all serializers in the app
+     */
+    globalSerializerNames() {
+        const dreamApp = DreamApp.getOrFail();
+        const serializers = dreamApp.serializers;
+        return Object.keys(serializers);
+    }
+}