@rvoh/dream 2.36.0 → 2.37.0

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

@@ -1,23 +1,24 @@
-import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import ts from 'typescript';
 import dbTypesFilenameForConnection from '../../db/helpers/dbTypesFilenameForConnection.js';
 import dreamSchemaTypesFilenameForConnection from '../../db/helpers/dreamSchemaTypesFilenameForConnection.js';
 import DreamApp from '../../dream-app/index.js';
 import Query from '../../dream/Query.js';
 import { ExplicitForeignKeyRequired, InvalidComputedForeignKey, } from '../../errors/associations/InvalidComputedForeignKey.js';
 import FailedToIdentifyAssociation from '../../errors/schema-builder/FailedToIdentifyAssociation.js';
+import camelize from '../camelize.js';
 import intersection from '../intersection.js';
 import sortBy from '../sortBy.js';
 import uniq from '../uniq.js';
 import ASTBuilder from './ASTBuilder.js';
+import { dbTypesName, dbTypesReservedNames } from './dbTypesNaming.js';
 import resolveIgnoredColumns from './resolveIgnoredColumns.js';
+import tableMatchesPattern from './tableMatchesPattern.js';
 /**
  * @internal
  *
  * This is a base class, which is inherited by the ASTSchemaBuilder and
- * the ASTKyselyCodegenEnhancer, both of which is responsible for building
- * up the output of the various type files consumed by dream internally.
+ * the ASTDbTypesBuilder, each of which builds one of the type files a
+ * connection's sync writes, from the same introspection of the connection.
  *
  * This base class is just a container for common methods used by both
  * classes. It requires a connectionName to be provided, unlike the underlying
@@ -27,9 +28,71 @@ import resolveIgnoredColumns from './resolveIgnoredColumns.js';
 export default class ASTConnectionBuilder extends ASTBuilder {
     connectionName;
     hasForeignKeyError = false;
-    constructor(connectionName) {
+    introspection;
+    introspectionFrom;
+    /**
+     * @param connectionName - the connection whose type file the builder writes
+     * @param opts.introspectionFrom - another builder of the same connection,
+     *   whose reading of it this builder takes instead of reading the connection
+     *   again, so that a sync reads each connection once for both type files
+     */
+    constructor(connectionName, opts = {}) {
         super();
         this.connectionName = connectionName;
+        this.introspectionFrom = opts.introspectionFrom;
+    }
+    /**
+     * @internal
+     *
+     * the connection's tables, sorted by their key in the DB interface, and its
+     * enums, read through the query driver once, by this builder or by the one
+     * it takes its introspection from. The tables that `tableIncludePattern`
+     * leaves out, or `tableExcludePattern` names, are left out.
+     */
+    async introspectedDatabase() {
+        this.introspection ||=
+            this.introspectionFrom?.introspectedDatabase() ??
+                (async () => {
+                    const dbDriverClass = Query.dbDriverClass(this.connectionName);
+                    const database = await dbDriverClass.introspectDatabase(this.connectionName);
+                    const credentials = DreamApp.getOrFail().dbCredentialsFor(this.connectionName);
+                    const includePattern = credentials?.tableIncludePattern;
+                    const excludePattern = credentials?.tableExcludePattern;
+                    return {
+                        ...database,
+                        tables: database.tables
+                            .filter(table => (!includePattern || tableMatchesPattern(table, includePattern)) &&
+                            !(excludePattern && tableMatchesPattern(table, excludePattern)))
+                            .sort((a, b) => this.tableKey(a).localeCompare(this.tableKey(b))),
+                    };
+                })();
+        return await this.introspection;
+    }
+    /**
+     * @internal
+     *
+     * the table's key in the DB interface and in Dream's schema: its name, or
+     * `<schema>.<name>` outside the connection's default schema
+     */
+    tableKey(table) {
+        return table.inDefaultSchema ? table.name : `${table.schema}.${table.name}`;
+    }
+    /**
+     * @internal
+     *
+     * the TypeScript name of each enum the connection's tables use, keyed by
+     * the enum's database name (see dbTypesName), with a number added when it
+     * would repeat an earlier enum's name or a name types/db.ts reserves
+     */
+    async enumTypeNames() {
+        const database = await this.introspectedDatabase();
+        const usedEnumNames = new Set(database.tables.flatMap(table => table.columns.map(column => column.enumName).filter(name => !!name)));
+        const takenNames = new Set(dbTypesReservedNames(database.tables));
+        const typeNames = new Map();
+        for (const enumName of [...usedEnumNames].sort()) {
+            typeNames.set(enumName, dbTypesName(enumName, takenNames));
+        }
+        return typeNames;
     }
     /**
      * @internal
@@ -55,26 +118,6 @@ export default class ASTConnectionBuilder extends ASTBuilder {
         const dreamApp = DreamApp.getOrFail();
         return path.join(dreamApp.projectRoot, dreamApp.paths.types, dbTypesFilenameForConnection(this.connectionName));
     }
-    /**
-     * @internal
-     *
-     * returns the db source file for the given connectionName, injecting
-     * the source file with the actual file contents, so that AST nodes
-     * can be built through ingesting.
-     */
-    async getDbSourceFile() {
-        const fileContent = await this.loadDbSyncFile();
-        return ts.createSourceFile('./db.js', fileContent, ts.ScriptTarget.Latest, true);
-    }
-    /**
-     * @internal
-     *
-     * reads the db source file for the given connection, returning the contents
-     * as a raw string
-     */
-    async loadDbSyncFile() {
-        return (await fs.readFile(this.dbPath())).toString();
-    }
     /**
      * @internal
      *
@@ -82,53 +125,14 @@ export default class ASTConnectionBuilder extends ASTBuilder {
      * can be read and injected into AST nodes.
      */
     async getSchemaData() {
-        const tables = await this.getTables();
+        const database = await this.introspectedDatabase();
+        const enumTypeNames = await this.enumTypeNames();
         const schemaData = {};
-        for (const table of tables) {
-            schemaData[table] = await this.tableData(table);
+        for (const table of database.tables) {
+            schemaData[this.tableKey(table)] = this.tableData(table, enumTypeNames);
         }
         return schemaData;
     }
-    /**
-     * @internal
-     *
-     * used by getSchemaData to build up all table data
-     */
-    async getTables() {
-        const fileContents = await this.loadDbSyncFile();
-        const tableLines = /export interface DB {([^}]*)}/.exec(fileContents)[1];
-        if (tableLines === undefined)
-            return [];
-        const tables = tableLines
-            .split('\n')
-            .map(line => {
-            const stingArray = line.split(':');
-            const substring = stingArray[0];
-            if (substring === undefined)
-                return '';
-            return substring.replace(/\s*/, '');
-        })
-            .filter(line => !!line);
-        return tables;
-    }
-    /**
-     * @internal
-     *
-     * finds all enums used by the app, and returns information
-     * about those enums that can be used for type generating purpposes
-     */
-    async getAllEnumValueNames() {
-        const schemaData = await this.getSchemaData();
-        const enumValueNames = Object.values(schemaData)
-            .map(tableData => Object.keys(tableData.columns)
-            .filter(columnName => !!tableData.columns[columnName]?.enumValues)
-            .map(columnName => ({
-            enumValues: tableData.columns[columnName].enumValues,
-            enumType: tableData.columns[columnName].enumType,
-        })))
-            .flat();
-        return enumValueNames;
-    }
     /**
      * @internal
      *
@@ -233,7 +237,8 @@ export default class ASTConnectionBuilder extends ASTBuilder {
      * retrieves the table data for an individual table.
      * Can be used to build up types
      */
-    async tableData(tableName) {
+    tableData(table, enumTypeNames) {
+        const tableName = this.tableKey(table);
         const dreamApp = DreamApp.getOrFail();
         const models = Object.values(dreamApp.models).filter(model => model.table === tableName);
         const maybeModel = models[0];
@@ -266,7 +271,7 @@ may need to update the table getter in the corresponding Dream.
                 default: uniq(models.flatMap(model => model['scopes'].default.map(scopeStatement => scopeStatement.method))),
                 named: uniq(models.flatMap(model => model['scopes'].named.map(scopeStatement => scopeStatement.method))),
             },
-            columns: this.withoutIgnoredColumns(await this.getColumnData(tableName, associationData), tableName),
+            columns: this.withoutIgnoredColumns(this.columnData(table, associationData, enumTypeNames), tableName),
             virtualColumns: uniq(models.flatMap(model => model['virtualAttributes'].map(prop => prop.property) || [])),
             associations: associationData,
             serializerKeys,
@@ -311,11 +316,28 @@ may need to update the table getter in the corresponding Dream.
     /**
      * @internal
      *
-     * retrieves the column data for an individual table and association.
-     * Can be used to build up types
+     * the columns of an introspected table, as Dream's schema records them,
+     * keyed by camelized column name
      */
-    async getColumnData(tableName, allTableAssociationData) {
-        const dbDriverClass = Query.dbDriverClass(this.connectionName);
-        return await dbDriverClass.getColumnData(this.connectionName, tableName, allTableAssociationData);
+    columnData(table, allTableAssociationData, enumTypeNames) {
+        const columnData = {};
+        for (const column of table.columns) {
+            const enumType = column.enumName ? enumTypeNames.get(column.enumName) : null;
+            columnData[camelize(column.name)] = {
+                dbType: column.dbType,
+                valueType: column.valueType,
+                allowNull: column.allowNull,
+                enumType,
+                enumValues: enumType ? `${enumType}Values` : null,
+                isArray: column.isArray,
+                foreignKey: allTableAssociationData[column.name]?.foreignKey || null,
+            };
+        }
+        return Object.keys(columnData)
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = columnData[key];
+            return acc;
+        }, {});
     }
 }

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

@@ -0,0 +1,132 @@
+import ts from 'typescript';
+import { CliFileWriter } from '../../cli/CliFileWriter.js';
+import camelize from '../camelize.js';
+import { propertyName } from './ASTBuilder.js';
+import ASTConnectionBuilder from './ASTConnectionBuilder.js';
+import autogeneratedFileDisclaimer from './autoGeneratedFileDisclaimer.js';
+import { dbTypesHelperNames, dbTypesName, dbTypesReservedNames, HELPER_TYPE_DECLARATIONS, PLAIN_ARRAY_VALUE_TYPES, } from './dbTypesNaming.js';
+const f = ts.factory;
+/**
+ * Writes a connection's types/db.ts (types/db.<connectionName>.ts for any
+ * connection but default) from its introspection: the Kysely `DB`
+ * interface, an interface for each table, each enum the tables use as a
+ * union of its values with a `<Enum>Values` const of them, and the column
+ * types those declare. Columns that the table's models ignore are left out,
+ * so that code still referring to one fails to compile.
+ */
+export default class ASTDbTypesBuilder extends ASTConnectionBuilder {
+    async build() {
+        const database = await this.introspectedDatabase();
+        const enumTypeNames = await this.enumTypeNames();
+        const helperNames = dbTypesHelperNames(database.tables);
+        const takenNames = new Set([...dbTypesReservedNames(database.tables), ...enumTypeNames.values()]);
+        const tables = database.tables.map(table => ({
+            key: this.tableKey(table),
+            interfaceName: dbTypesName(this.tableKey(table), takenNames),
+            columns: this.columns(table, enumTypeNames),
+        }));
+        const enumValues = new Map(database.enums.map(databaseEnum => [databaseEnum.name, databaseEnum.values]));
+        const typeDeclarations = [
+            ...helperNames.map(name => ({ name, statements: [helperTypeDeclaration(name)] })),
+            ...[...enumTypeNames].map(([enumName, typeName]) => ({
+                name: typeName,
+                statements: enumDeclarations(typeName, [...(enumValues.get(enumName) ?? [])].sort((a, b) => a.localeCompare(b))),
+            })),
+        ];
+        const tableInterfaces = [...tables]
+            .sort((a, b) => a.interfaceName.localeCompare(b.interfaceName))
+            .map(table => f.createInterfaceDeclaration([f.createModifier(ts.SyntaxKind.ExportKeyword)], table.interfaceName, undefined, undefined, table.columns.map(column => f.createPropertySignature(undefined, propertyName(column.key), undefined, column.type))));
+        const dbMembers = tables.map(table => ({
+            name: propertyName(table.key),
+            type: f.createTypeReferenceNode(table.interfaceName),
+        }));
+        const statements = [
+            ...typeDeclarations
+                .sort((a, b) => a.name.localeCompare(b.name))
+                .flatMap(declaration => declaration.statements),
+            ...tableInterfaces,
+            f.createInterfaceDeclaration([f.createModifier(ts.SyntaxKind.ExportKeyword)], 'DB', undefined, undefined, dbMembers.map(member => f.createPropertySignature(undefined, member.name, undefined, member.type))),
+            f.createClassDeclaration([f.createModifier(ts.SyntaxKind.ExportKeyword)], 'DBClass', undefined, undefined, dbMembers.map(member => f.createPropertyDeclaration(undefined, member.name, undefined, member.type, undefined))),
+        ];
+        const sourceFile = ts.createSourceFile('', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+        const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed, omitTrailingSemicolon: true });
+        const print = (node) => printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+        const output = await this.prettier(`\
+${autogeneratedFileDisclaimer()}
+${this.imports(helperNames).map(print).join('\n')}
+
+${statements.map(print).join('\n\n')}
+`);
+        await CliFileWriter.write(this.dbPath(), output);
+    }
+    /**
+     * @internal
+     *
+     * the table's columns, minus those its models ignore, sorted by name, each
+     * with its key (the camelized column name) and its type
+     */
+    columns(table, enumTypeNames) {
+        const ignoredColumns = this.ignoredColumnsForTable(this.tableKey(table));
+        return [...table.columns]
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(column => ({ key: camelize(column.name), type: columnType(column, enumTypeNames) }))
+            .filter(column => !ignoredColumns.has(column.key));
+    }
+    /**
+     * @internal
+     *
+     * the file's imports: Dream's date and time classes, Kysely's ColumnType,
+     * and postgres-interval's type when a column is an interval
+     */
+    imports(helperNames) {
+        return [
+            ...this.dateAndDateTimeImports(),
+            typeImport('ColumnType', 'kysely'),
+            ...(helperNames.includes('Interval') ? [typeImport('IPostgresInterval', 'postgres-interval')] : []),
+        ];
+    }
+}
+/**
+ * The column's type in its table's interface: its value type (an array of
+ * them for an array column), `| null` when it allows null, all wrapped in
+ * `Generated<>` when an insert may leave it out.
+ */
+function columnType(column, enumTypeNames) {
+    const valueType = f.createTypeReferenceNode(column.valueType === 'enum' ? enumTypeNames.get(column.enumName) : column.valueType);
+    let type = valueType;
+    if (column.isArray) {
+        type = PLAIN_ARRAY_VALUE_TYPES.includes(column.valueType)
+            ? f.createArrayTypeNode(valueType)
+            : f.createTypeReferenceNode('ArrayType', [valueType]);
+    }
+    if (column.allowNull)
+        type = f.createUnionTypeNode([type, f.createLiteralTypeNode(f.createNull())]);
+    if (column.hasDefault)
+        type = f.createTypeReferenceNode('Generated', [type]);
+    return type;
+}
+/**
+ * An enum's type, the union of its values (`never` when it has none), and
+ * its `<Enum>Values` const, which lists them.
+ */
+function enumDeclarations(typeName, values) {
+    const exportModifier = f.createModifier(ts.SyntaxKind.ExportKeyword);
+    return [
+        f.createTypeAliasDeclaration([exportModifier], typeName, undefined, values.length
+            ? f.createUnionTypeNode(values.map(value => f.createLiteralTypeNode(f.createStringLiteral(value))))
+            : f.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword)),
+        f.createVariableStatement([exportModifier], f.createVariableDeclarationList([
+            f.createVariableDeclaration(`${typeName}Values`, undefined, undefined, f.createAsExpression(f.createArrayLiteralExpression(values.map(value => f.createStringLiteral(value))), f.createKeywordTypeNode(ts.SyntaxKind.ConstKeyword))),
+        ], ts.NodeFlags.Const)),
+    ];
+}
+/**
+ * A type types/db.ts declares for its columns, parsed from its declaration,
+ * which is fixed rather than built from the database.
+ */
+function helperTypeDeclaration(name) {
+    return ts.createSourceFile('', HELPER_TYPE_DECLARATIONS[name], ts.ScriptTarget.Latest, false, ts.ScriptKind.TS).statements[0];
+}
+function typeImport(name, moduleName) {
+    return f.createImportDeclaration(undefined, f.createImportClause(true, undefined, f.createNamedImports([f.createImportSpecifier(false, undefined, f.createIdentifier(name))])), f.createStringLiteral(moduleName));
+}

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

@@ -1,8 +1,8 @@
 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 { propertyName } from './ASTBuilder.js';
 import ASTConnectionBuilder from './ASTConnectionBuilder.js';
 import autogeneratedFileDisclaimer from './autoGeneratedFileDisclaimer.js';
 const f = ts.factory;
@@ -51,11 +51,10 @@ export default class ASTSchemaBuilder extends ASTConnectionBuilder {
         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([
+            return f.createPropertyAssignment(propertyName(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)))),
@@ -84,8 +83,8 @@ export default class ASTSchemaBuilder extends ASTConnectionBuilder {
                     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([
+                    const coercedType = this.coercedType(columnData, importedTypes);
+                    return f.createPropertyAssignment(propertyName(columnName), f.createObjectLiteralExpression([
                         f.createPropertyAssignment(f.createIdentifier('coercedType'), f.createAsExpression(f.createObjectLiteralExpression(), coercedType)),
                         f.createPropertyAssignment(f.createIdentifier('enumType'), enumTypeNode
                             ? f.createAsExpression(f.createObjectLiteralExpression(), enumTypeNode)
@@ -238,83 +237,40 @@ ${output}`;
     /**
      * @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.
+     * the type Dream gives the column's values: Int8 (bigint) values are
+     * strings, Numeric values numbers, and a Timestamp is a CalendarDate for a
+     * date column and a DateTime otherwise. Types declared in the db.ts file
+     * (Json and the like) are added to importedTypes.
      */
-    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);
+    coercedType(columnData, importedTypes) {
+        const valueType = this.coercedValueType(columnData, importedTypes);
+        const type = columnData.isArray ? f.createArrayTypeNode(valueType) : valueType;
+        return columnData.allowNull
+            ? f.createUnionTypeNode([type, f.createLiteralTypeNode(f.createNull())])
+            : type;
     }
-    /**
-     * @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 = this.isDateDbType(dbType);
-        const isTime = this.isTimeWithoutTimeZoneDbType(dbType);
-        const isTimeTz = this.isTimeWithTimeZoneDbType(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 'string':
-                    // Kysely-codegen types TIME columns as string, we need to check dbType
-                    if (isTime)
-                        return f.createTypeReferenceNode('ClockTime');
-                    if (isTimeTz)
-                        return f.createTypeReferenceNode('ClockTimeTz');
-                    return defaultReturnNode;
-                case 'string[]':
-                    // Kysely-codegen types TIME[] columns as string[], we need to check dbType
-                    if (isTime)
-                        return f.createArrayTypeNode(f.createTypeReferenceNode('ClockTime'));
-                    if (isTimeTz)
-                        return f.createArrayTypeNode(f.createTypeReferenceNode('ClockTimeTz'));
-                    return defaultReturnNode;
-                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;
+    coercedValueType(columnData, importedTypes) {
+        switch (columnData.valueType) {
+            case 'string':
+            case 'Int8':
+                return f.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+            case 'number':
+            case 'Numeric':
+                return f.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+            case 'boolean':
+                return f.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
+            case 'Timestamp':
+                return f.createTypeReferenceNode(this.isDateDbType(columnData.dbType) ? 'CalendarDate' : 'DateTime');
+            case 'enum':
+                return f.createTypeReferenceNode(columnData.enumType);
+            case 'Json':
+            case 'Interval':
+            case 'Point':
+            case 'Circle':
+                importedTypes.push(columnData.valueType);
+                return f.createTypeReferenceNode(columnData.valueType);
+            default:
+                return f.createTypeReferenceNode(columnData.valueType);
+        }
     }
 }

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

@@ -0,0 +1,90 @@
+import pascalize from '../pascalize.js';
+/**
+ * @internal
+ *
+ * The value types an array column lists in a plain array in types/db.ts. Any
+ * other is listed through `ArrayType`, which turns a `ColumnType` (such as
+ * `Int8`) into a `ColumnType` of arrays.
+ */
+export const PLAIN_ARRAY_VALUE_TYPES = ['string', 'number', 'boolean', 'ClockTime', 'ClockTimeTz'];
+/**
+ * @internal
+ *
+ * The declaration of each type that types/db.ts declares for its columns.
+ */
+export const HELPER_TYPE_DECLARATIONS = {
+    ArrayType: 'export type ArrayType<T> = ArrayTypeImpl<T> extends (infer U)[] ? U[] : ArrayTypeImpl<T>',
+    ArrayTypeImpl: 'export type ArrayTypeImpl<T> = T extends ColumnType<infer S, infer I, infer U> ? ColumnType<S[], I[], U[]> : T[]',
+    Circle: 'export type Circle = { x: number; y: number; radius: number }',
+    Generated: 'export type Generated<T> = T extends ColumnType<infer S, infer I, infer U> ? ColumnType<S, I | undefined, U> : ColumnType<T, T | undefined, T>',
+    Int8: 'export type Int8 = ColumnType<string, bigint | number | string, bigint | number | string>',
+    Interval: 'export type Interval = ColumnType<IPostgresInterval, IPostgresInterval | number | string, IPostgresInterval | number | string>',
+    Json: 'export type Json = JsonValue',
+    JsonArray: 'export type JsonArray = JsonValue[]',
+    JsonObject: 'export type JsonObject = {\n  [x: string]: JsonValue | undefined\n}',
+    JsonPrimitive: 'export type JsonPrimitive = boolean | number | string | null',
+    JsonValue: 'export type JsonValue = JsonArray | JsonObject | JsonPrimitive',
+    Numeric: 'export type Numeric = ColumnType<string, number | string, number | string>',
+    Point: 'export type Point = { x: number; y: number }',
+    Timestamp: 'export type Timestamp = ColumnType<DateTime | CalendarDate>',
+};
+/**
+ * @internal
+ *
+ * The types types/db.ts declares for the given tables' columns.
+ */
+export function dbTypesHelperNames(tables) {
+    const names = new Set();
+    for (const column of tables.flatMap(table => table.columns)) {
+        if (column.hasDefault)
+            names.add('Generated');
+        if (column.isArray && !PLAIN_ARRAY_VALUE_TYPES.includes(column.valueType)) {
+            names.add('ArrayType').add('ArrayTypeImpl');
+        }
+        if (column.valueType === 'Json') {
+            names.add('Json').add('JsonArray').add('JsonObject').add('JsonPrimitive').add('JsonValue');
+        }
+        if (HELPER_TYPE_DECLARATIONS[column.valueType])
+            names.add(column.valueType);
+    }
+    return [...names].sort();
+}
+/**
+ * @internal
+ *
+ * The names that types/db.ts declares, imports or uses from JavaScript for
+ * the given tables, which no enum or table interface may take.
+ */
+export function dbTypesReservedNames(tables) {
+    const valueTypes = new Set(tables.flatMap(table => table.columns.map(column => column.valueType)));
+    return [
+        'CalendarDate',
+        'ClockTime',
+        'ClockTimeTz',
+        'ColumnType',
+        'DB',
+        'DBClass',
+        'DateTime',
+        ...dbTypesHelperNames(tables),
+        ...(valueTypes.has('Date') ? ['Date'] : []),
+        ...(valueTypes.has('Buffer') ? ['Buffer'] : []),
+        ...(valueTypes.has('Interval') ? ['IPostgresInterval'] : []),
+    ];
+}
+/**
+ * @internal
+ *
+ * The TypeScript name types/db.ts gives a table or enum: its name, with a
+ * schema's `.` as `_`, pascalized, and prefixed with `_` when it would start
+ * with a digit. A number is added when the name is in `takenNames`, which
+ * the chosen name joins.
+ */
+export function dbTypesName(name, takenNames) {
+    const pascalized = pascalize(name.replace(/\./g, '_'));
+    const baseName = /^\d/.test(pascalized) ? `_${pascalized}` : pascalized;
+    let typeName = baseName;
+    for (let suffix = 2; takenNames.has(typeName); suffix++)
+        typeName = `${baseName}${suffix}`;
+    takenNames.add(typeName);
+    return typeName;
+}

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

@@ -0,0 +1,21 @@
+import { matchesGlob } from 'node:path';
+/**
+ * @internal
+ *
+ * Whether a table matches a `tableIncludePattern` or `tableExcludePattern`:
+ * a glob in Node's `path.matchesGlob` syntax (e.g. `chalupas*`, `public.*`
+ * or `public.+(users|posts)`), compared without regard to case. A pattern
+ * that contains a `.` is matched against `<schema>.<name>`, and any other
+ * against the table's name alone. As with micromatch, a leading `!` (one that
+ * does not open an extglob `!(…)`) negates the pattern, and a backslash
+ * before a glob character such as `*` or `?` matches that character itself.
+ */
+export default function tableMatchesPattern(table, pattern) {
+    if (/^!(?!\()/.test(pattern))
+        return !tableMatchesPattern(table, pattern.slice(1));
+    const subject = pattern.includes('.') ? `${table.schema ?? '*'}.${table.name}` : table.name;
+    // matchesGlob does not read a backslash as an escape, so an escaped
+    // character is matched through a class of that one character
+    const glob = pattern.replace(/\\(.)/g, '[$1]');
+    return matchesGlob(subject.toLowerCase(), glob.toLowerCase());
+}

package/dist/esm/src/Dream.js

@@ -3019,7 +3019,9 @@ export default class Dream {
      * Writes the value into the current attributes as given, with none of
      * setAttribute's checks. Only for values Dream already trusts: a row read
      * from the database, and the ciphertext the @Encrypted property setter
-     * has just produced. Every caller-supplied value goes through setAttribute.
+     * writes (freshly encrypted, or the ciphertext as loaded or last saved,
+     * which it keeps when that already holds the assigned plaintext). Every
+     * caller-supplied value goes through setAttribute.
      */
     setAttributeUnchecked(column, val) {
         this.currentAttributes[column] = val;

package/dist/esm/src/db/dataTypes.js

@@ -1,11 +1,3 @@
-export default function dataTypes() {
-    // In the future, when we support multiple db drivers,
-    // this will need to be updated
-    return postgresDatatypes;
-}
-export function isPrimitiveDataType(type) {
-    return dataTypes().includes(type.replace(/\[\]$/, ''));
-}
 export const postgresDatatypes = [
     'bigint',
     'bigserial',