@rvoh/dream 2.36.0 → 2.37.0

package/dist/esm/src/decorators/field/Encrypted.js

@@ -96,9 +96,14 @@ export default function Encrypted(columnOrOptions) {
                      */
                     if (this.columnSetterGuardActivated)
                         return;
-                    // the value was just encrypted, so it bypasses setAttribute's check
-                    // that a backing column receives only decryptable ciphertext
-                    this.setAttributeUnchecked(encryptedKey, InternalEncrypt.encryptColumn(val));
+                    // On a persisted record, the ciphertext as loaded or last saved is
+                    // kept when the current key opens it to the assigned value, so
+                    // assigning a property the plaintext it already holds leaves the
+                    // record clean; any other value is encrypted fresh. Either way the
+                    // value is ciphertext Dream produced, so it bypasses setAttribute's
+                    // check that a backing column receives only decryptable ciphertext
+                    const dream = this;
+                    this.setAttributeUnchecked(encryptedKey, InternalEncrypt.reuseOrEncryptColumn(val, dream.isPersisted ? dream['frozenAttributes'][encryptedKey] : undefined));
                 },
                 configurable: false,
             });

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

@@ -91,14 +91,12 @@ export default class QueryDriverBase {
      * 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.
+     * 1. generate a types/db.ts file in the same shape as the existing one.
+     *    KyselyQueryDriver does this with the ASTDbTypesBuilder, which writes
+     *    it from {@link introspectDatabase}.
      * 2. generate a types/dream.ts file in the same shape as the existing
-     *    one. This is normally done using the ASTSchemaBuilder
-     *    but this will likely need to be overridden to tailor to your custom
-     *    database engine.
+     *    one. KyselyQueryDriver does this with the ASTSchemaBuilder, which
+     *    also reads the connection through {@link introspectDatabase}.
      */
     // eslint-disable-next-line @typescript-eslint/require-await
     static async sync(connectionName, _, 
@@ -292,15 +290,20 @@ export default class QueryDriverBase {
     keys) {
         throw new Error('override acquireAdvisoryTransactionLocks in child class');
     }
+    /**
+     * Reads the tables, columns and enums of the connection's database, from
+     * which `sync` writes the connection's `types/db.ts` and `types/dream.ts`.
+     * It returns every table the connection can read, sorted by schema and
+     * name; `sync` applies `tableIncludePattern` and `tableExcludePattern`
+     * itself.
+     *
+     * @param connectionName - the connection to read
+     */
     // eslint-disable-next-line @typescript-eslint/require-await
-    static async getColumnData(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    connectionName, 
+    static async introspectDatabase(
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    tableName, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    allTableAssociationData) {
-        throw new Error('implement getColumnData in child class');
+    connectionName) {
+        throw new Error('implement introspectDatabase in child class');
     }
     /**
      * @internal
@@ -695,16 +698,6 @@ export default class QueryDriverBase {
     reallyDestroy) {
         throw new Error('implement destroyDream in child class');
     }
-    static get syncDialect() {
-        return 'postgres';
-    }
-    /** @internal Resolve the credential used by the database type generator. */
-    static codegenPassword(password) {
-        if (typeof password === 'function') {
-            throw new Error('This database adapter does not support a password provider for type generation');
-        }
-        return Promise.resolve(password);
-    }
     /**
      * Returns the sql that would be executed by this Query
      *

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

@@ -12,7 +12,6 @@ import pluralize from 'pluralize-esm';
 import { CliFileWriter } from '../../cli/CliFileWriter.js';
 import DreamCLI from '../../cli/index.js';
 import { CHECK_VIOLATION, COLUMN_OVERFLOW, INVALID_INPUT_SYNTAX, NOT_NULL_VIOLATION, pgErrorType, } from '../../db/errors.js';
-import syncDbTypesFiles from '../../db/helpers/syncDbTypesFiles.js';
 import { default as _db } from '../../db/index.js';
 import validateColumn from '../../db/validators/validateColumn.js';
 import associationToGetterSetterProp from '../../decorators/field/association/associationToGetterSetterProp.js';
@@ -39,8 +38,6 @@ import ColumnOverflow from '../../errors/db/ColumnOverflow.js';
 import DataTypeColumnTypeMismatch from '../../errors/db/DataTypeColumnTypeMismatch.js';
 import NotNullViolation from '../../errors/db/NotNullViolation.js';
 import UnexpectedUndefined from '../../errors/UnexpectedUndefined.js';
-import ASTGlobalSchemaBuilder from '../../helpers/cli/ASTGlobalSchemaBuilder.js';
-import ASTSchemaBuilder from '../../helpers/cli/ASTSchemaBuilder.js';
 import generateMigration from '../../helpers/cli/generateMigration.js';
 import compact from '../../helpers/compact.js';
 import { normalizeDataForDb } from '../../helpers/db/normalizeDataForDb.js';
@@ -51,7 +48,6 @@ import isEmpty from '../../helpers/isEmpty.js';
 import maybeNamespacedColumnNameToColumnName from '../../helpers/maybeNamespacedColumnNameToColumnName.js';
 import namespaceColumn from '../../helpers/namespaceColumn.js';
 import objectPathsToArrays from '../../helpers/objectPathsToArrays.js';
-import pascalize from '../../helpers/pascalize.js';
 import protectAgainstPollutingAssignment from '../../helpers/protectAgainstPollutingAssignment.js';
 import { Range } from '../../helpers/range.js';
 import snakeify from '../../helpers/snakeify.js';
@@ -200,13 +196,16 @@ export default class KyselyQueryDriver extends QueryDriverBase {
      * */
     static async sync(connectionName, onSync, options = {}) {
         try {
-            if (!options?.schemaOnly) {
+            const { ASTDbTypesBuilder, ASTSchemaBuilder, ASTGlobalSchemaBuilder } = await loadTypeFileBuilders();
+            // the schema builder takes the db types builder's reading of the
+            // connection, so that a sync reads each connection once for both files
+            const dbTypesBuilder = options?.schemaOnly ? undefined : new ASTDbTypesBuilder(connectionName);
+            if (dbTypesBuilder) {
                 await DreamCLI.logger.logProgress(`introspecting db for connection: ${connectionName}...`, async () => {
-                    // this calls kysely-codegen under the hood
-                    await syncDbTypesFiles(connectionName);
+                    await dbTypesBuilder.build();
                 });
             }
-            const newSchemaBuilder = new ASTSchemaBuilder(connectionName);
+            const newSchemaBuilder = new ASTSchemaBuilder(connectionName, { introspectionFrom: dbTypesBuilder });
             await DreamCLI.logger.logProgress(`building dream schema for connection ${connectionName}...`, async () => {
                 await newSchemaBuilder.build();
             });
@@ -243,12 +242,6 @@ export default class KyselyQueryDriver extends QueryDriverBase {
             throw error;
         }
     }
-    static get syncDialect() {
-        return 'postgres';
-    }
-    static async codegenPassword(password) {
-        return typeof password === 'function' ? await password() : password;
-    }
     /**
      * @internal
      *
@@ -369,15 +362,6 @@ export default class KyselyQueryDriver extends QueryDriverBase {
         await dreamTransaction.runAfterCommitHooks();
         return callbackResponse;
     }
-    /**
-     * @internal
-     *
-     * this is used by getColumnData to serialize enums
-     */
-    static enumType(row) {
-        const enumName = pascalize(row.udtName.replace(/\[\]$/, ''));
-        return enumName;
-    }
     /**
      * @internal
      *
@@ -2828,3 +2812,18 @@ function shouldSoftDelete(dream, reallyDestroy) {
     const dreamClass = dream.constructor;
     return dreamClass['softDelete'] && !reallyDestroy;
 }
+/**
+ * The type file builders import `typescript`, a devDependency that a
+ * production install does not have, and this driver is reached from the
+ * package's main entry, so they are loaded only when `sync` runs: in
+ * development, and never in production, where migrations run with
+ * `--skip-sync`.
+ */
+async function loadTypeFileBuilders() {
+    const [{ default: ASTDbTypesBuilder }, { default: ASTSchemaBuilder }, { default: ASTGlobalSchemaBuilder }] = await Promise.all([
+        import('../../helpers/cli/ASTDbTypesBuilder.js'),
+        import('../../helpers/cli/ASTSchemaBuilder.js'),
+        import('../../helpers/cli/ASTGlobalSchemaBuilder.js'),
+    ]);
+    return { ASTDbTypesBuilder, ASTSchemaBuilder, ASTGlobalSchemaBuilder };
+}

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

@@ -9,11 +9,9 @@
 import pg from 'pg';
 import { sql } from 'kysely';
 import DreamCLI from '../../cli/index.js';
-import { isPrimitiveDataType } from '../../db/dataTypes.js';
 import { DEADLOCK_DETECTED, LOCK_NOT_AVAILABLE, pgErrorType, UNIQUE_VIOLATION } from '../../db/errors.js';
 import DreamApp from '../../dream-app/index.js';
 import SortableScopeLockWaitTimedOut from '../../errors/SortableScopeLockWaitTimedOut.js';
-import camelize from '../../helpers/camelize.js';
 import { findCitextArrayOid, findCorrespondingArrayOid, findEnumArrayOids, parsePostgresBigint, parsePostgresDate, parsePostgresDatetime, parsePostgresDatetimeTz, parsePostgresDecimal, parsePostgresTime, parsePostgresTimeTz, } from '../../helpers/customPgParsers.js';
 import { testDatabasePoolSize } from '../../db/testDatabasePool.js';
 import EnvInternal from '../../helpers/EnvInternal.js';
@@ -139,38 +137,96 @@ export default class PostgresQueryDriver extends KyselyQueryDriver {
         }
     }
     /**
-     * @internal
+     * Reads the tables, views, materialized views, and partitioned and foreign
+     * tables of every schema the connection's user can use, except Postgres's
+     * own schemas, tables that inherit from another (partitions included) and
+     * Kysely's migration tables. A domain column reads as the type at the
+     * bottom of its domains. An enum outside the `public` schema is named
+     * `<schema>.<name>`.
      *
-     * this is used by the SchemaBuilder to store column data permanently
-     * within the types/dream.ts file.
+     * @param connectionName - the connection to read
      */
-    static async getColumnData(connectionName, tableName, allTableAssociationData) {
+    static async introspectDatabase(connectionName) {
         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);
-        const rows = columnToDBTypeMap.rows;
-        const columnData = {};
-        rows.forEach(row => {
-            const isEnum = ['USER-DEFINED', 'ARRAY'].includes(row.dataType) && !isPrimitiveDataType(row.udtName);
-            const isArray = ['ARRAY'].includes(row.dataType);
-            const associationMetadata = allTableAssociationData[row.columnName];
-            columnData[camelize(row.columnName)] = {
-                dbType: row.udtName,
-                allowNull: row.isNullable === 'YES',
-                enumType: isEnum ? this.enumType(row) : null,
-                enumValues: isEnum ? `${this.enumType(row)}Values` : null,
-                isArray,
-                foreignKey: associationMetadata?.foreignKey || null,
-            };
-        });
-        return Object.keys(columnData)
-            .sort()
-            .reduce((acc, key) => {
-            if (columnData[key] === undefined)
-                return acc;
-            acc[key] = columnData[key];
-            return acc;
-        }, {});
+        const columnRows = (await sql `
+        WITH RECURSIVE domain_base(oid, base, domainnotnull) AS (
+          SELECT dom.oid, dom.typbasetype, dom.typnotnull
+          FROM pg_catalog.pg_type AS dom
+          JOIN pg_catalog.pg_type AS typ ON typ.oid = dom.typbasetype
+          WHERE typ.typtype <> 'd'
+          UNION ALL
+          SELECT dom.oid, parent.base, parent.domainnotnull OR dom.typnotnull
+          FROM domain_base AS parent
+          JOIN pg_catalog.pg_type AS dom ON dom.typbasetype = parent.oid
+        )
+        SELECT
+          ns.nspname AS schemaname,
+          cls.relname AS tablename,
+          att.attname AS columnname,
+          format_type(val.oid, NULL) || CASE WHEN base.typcategory = 'A' THEN '[]' ELSE '' END AS dbtype,
+          base.typcategory = 'A' AS isarray,
+          format_type(val.oid, NULL) AS valuedbtype,
+          CASE WHEN val.typtype = 'e' THEN
+            CASE WHEN valns.nspname = 'public' THEN val.typname ELSE valns.nspname || '.' || val.typname END
+          END AS enumname,
+          NOT (att.attnotnull OR coalesce(columndomain.domainnotnull, false)) AS nullable,
+          (att.atthasdef OR att.attidentity <> '') AS hasdefault
+        FROM pg_catalog.pg_class AS cls
+        JOIN pg_catalog.pg_namespace AS ns ON ns.oid = cls.relnamespace
+        JOIN pg_catalog.pg_attribute AS att ON att.attrelid = cls.oid
+        LEFT JOIN domain_base AS columndomain ON columndomain.oid = att.atttypid
+        JOIN pg_catalog.pg_type AS base ON base.oid = coalesce(columndomain.base, att.atttypid)
+        LEFT JOIN domain_base AS elemdomain ON elemdomain.oid = base.typelem
+        JOIN pg_catalog.pg_type AS val
+          ON val.oid = CASE WHEN base.typcategory = 'A' THEN coalesce(elemdomain.base, base.typelem) ELSE base.oid END
+        JOIN pg_catalog.pg_namespace AS valns ON valns.oid = val.typnamespace
+        WHERE cls.relkind IN ('r', 'p', 'v', 'm', 'f')
+          AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_inherits AS inh WHERE inh.inhrelid = cls.oid)
+          AND ns.nspname !~ '^pg_'
+          AND ns.nspname <> 'information_schema'
+          AND has_schema_privilege(ns.oid, 'USAGE')
+          AND cls.relname NOT IN ('kysely_migration', 'kysely_migration_lock')
+          AND att.attnum > 0
+          AND NOT att.attisdropped
+        ORDER BY ns.nspname, cls.relname, att.attnum
+      `.execute(db)).rows;
+        const enumRows = (await sql `
+        SELECT
+          CASE WHEN ns.nspname = 'public' THEN typ.typname ELSE ns.nspname || '.' || typ.typname END AS enumname,
+          enm.enumlabel AS label
+        FROM pg_catalog.pg_enum AS enm
+        JOIN pg_catalog.pg_type AS typ ON typ.oid = enm.enumtypid
+        JOIN pg_catalog.pg_namespace AS ns ON ns.oid = typ.typnamespace
+      `.execute(db)).rows;
+        const tables = [];
+        for (const row of columnRows) {
+            let table = tables.at(-1);
+            if (table?.schema !== row.schemaname || table.name !== row.tablename) {
+                table = {
+                    schema: row.schemaname,
+                    name: row.tablename,
+                    inDefaultSchema: row.schemaname === 'public',
+                    columns: [],
+                };
+                tables.push(table);
+            }
+            table.columns.push({
+                name: row.columnname,
+                dbType: row.dbtype,
+                valueType: row.enumname ? 'enum' : (POSTGRES_VALUE_TYPES[row.valuedbtype] ?? 'string'),
+                enumName: row.enumname,
+                isArray: row.isarray,
+                allowNull: row.nullable,
+                hasDefault: row.hasdefault,
+            });
+        }
+        const enumValues = {};
+        for (const row of enumRows)
+            (enumValues[row.enumname] ||= []).push(row.label);
+        return {
+            tables,
+            enums: Object.keys(enumValues).map(name => ({ name, values: enumValues[name] })),
+        };
     }
     static async duplicateDatabase(connectionName) {
         const dreamApp = DreamApp.getOrFail();
@@ -353,3 +409,29 @@ export default class PostgresQueryDriver extends KyselyQueryDriver {
         };
     }
 }
+/**
+ * The `types/db.ts` type of one value of each Postgres type Dream reads as
+ * something other than a string, keyed by the type's name as `format_type`
+ * gives it. Every other type, enums aside, reads as a string.
+ */
+const POSTGRES_VALUE_TYPES = {
+    smallint: 'number',
+    integer: 'number',
+    real: 'number',
+    'double precision': 'number',
+    oid: 'number',
+    bigint: 'Int8',
+    numeric: 'Numeric',
+    boolean: 'boolean',
+    date: 'Timestamp',
+    'timestamp without time zone': 'Timestamp',
+    'timestamp with time zone': 'Timestamp',
+    'time without time zone': 'ClockTime',
+    'time with time zone': 'ClockTimeTz',
+    json: 'Json',
+    jsonb: 'Json',
+    bytea: 'Buffer',
+    interval: 'Interval',
+    point: 'Point',
+    circle: 'Circle',
+};

package/dist/esm/src/encrypt/InternalEncrypt.js

@@ -14,6 +14,34 @@ export default class InternalEncrypt {
             return null;
         return this.doEncryption(data, encryptOpts.current);
     }
+    /**
+     * Returns `existingCiphertext` when the current column key opens it to a
+     * value whose JSON serialization equals `data`'s, the plaintext
+     * `encryptColumn(data)` would encrypt, and otherwise `encryptColumn(data)`.
+     * A value only the legacy key opens, ciphertext no key opens, and a
+     * missing `existingCiphertext` all get fresh ciphertext. It never calls
+     * `onLegacyKeyUsed`.
+     */
+    static reuseOrEncryptColumn(data, existingCiphertext) {
+        if (data === null || data === undefined || typeof existingCiphertext !== 'string')
+            return this.encryptColumn(data);
+        const dreamApp = DreamApp.getOrFail();
+        const encryptOpts = dreamApp.encryption?.columns;
+        if (!encryptOpts)
+            throw new MissingColumnEncryptionOpts();
+        let existingPlaintext;
+        try {
+            existingPlaintext = Encrypt.decrypt(existingCiphertext, encryptOpts.current);
+        }
+        catch (err) {
+            if (err instanceof DecryptionError || err instanceof DecryptionParseError)
+                return this.encryptColumn(data);
+            throw err;
+        }
+        return JSON.stringify(existingPlaintext) === JSON.stringify(data)
+            ? existingCiphertext
+            : this.encryptColumn(data);
+    }
     /**
      * Decrypts `data` with the column keys, current then legacy.
      * `onLegacyKeyUsed` is passed to `Encrypt.decrypt`, so it is called only

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

@@ -7,7 +7,7 @@ const f = ts.factory;
  * @internal
  *
  * This is a base class, which is inherited by the ASTSchemaBuilder,
- * the ASTKyselyCodegenEnhancer, and the ASTGlobalSchemaBuilder,
+ * the ASTDbTypesBuilder, and the ASTGlobalSchemaBuilder,
  * each of which is responsible for building up the output of the various
  * type files consumed by dream internally.
  *
@@ -23,131 +23,6 @@ export default class ASTBuilder {
     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
      *
@@ -189,25 +64,6 @@ export default class ASTBuilder {
             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
      *
@@ -251,28 +107,6 @@ export default class ASTBuilder {
             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
      *
@@ -291,39 +125,14 @@ export default class ASTBuilder {
     isDateDbType(dbType) {
         return /^date[[\]]*$/.test(dbType);
     }
-    /**
-     * @internal
-     *
-     * checks if a database type is a time without time zone type (with optional array suffix)
-     */
-    isTimeWithoutTimeZoneDbType(dbType) {
-        return /^time without time zone[[\]]*$/.test(dbType);
-    }
-    /**
-     * @internal
-     *
-     * checks if a database type is a time with time zone type (with optional array suffix)
-     */
-    isTimeWithTimeZoneDbType(dbType) {
-        return /^time with time zone[[\]]*$/.test(dbType);
-    }
-    /**
-     * @internal
-     *
-     * checks if a database type is any time type (with or without time zone, with optional array suffix)
-     */
-    isTimeDbType(dbType) {
-        return /^time (without|with) time zone(\[\])?$/.test(dbType);
-    }
-    /**
-     * @internal
-     *
-     * checks if a TypeScript type node represents a string-like type
-     * (string keyword, string type reference, or string literal)
-     */
-    isStringLikeType(node, sourceFile) {
-        return (node.kind === ts.SyntaxKind.StringKeyword ||
-            (ts.isTypeReferenceNode(node) && node.typeName.getText(sourceFile) === 'string') ||
-            (ts.isLiteralTypeNode(node) && ts.isStringLiteral(node.literal)));
-    }
+}
+/**
+ * @internal
+ *
+ * A property name for an object literal, interface or class: the name itself
+ * when it is an identifier, and a string literal otherwise, such as a table
+ * outside the default schema (`inventory.parts`).
+ */
+export function propertyName(name) {
+    return /^[A-Za-z_$][\w$]*$/.test(name) ? f.createIdentifier(name) : f.createStringLiteral(name);
 }