@rvoh/dream 2.36.0 → 2.37.0

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

@@ -1,9 +1,7 @@
 import { CompiledQuery, DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
-import type { DreamDbConfig } from '../../dream-app/index.js';
 import Dream from '../../Dream.js';
-import { SchemaBuilderAssociationData, SchemaBuilderColumnData } from '../../helpers/cli/ASTBuilder.js';
 import { AssociationStatement, OrderQueryStatement } from '../../types/associations/shared.js';
-import { DbConnectionType, LegacyCompatiblePrimaryKeyType } from '../../types/db.js';
+import { DbConnectionType, IntrospectedDatabase, LegacyCompatiblePrimaryKeyType } from '../../types/db.js';
 import { DreamColumnNames, DreamConstructorType, DreamTableSchema } from '../../types/dream.js';
 import { PreloadedDreamsAndWhatTheyPointTo, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../../types/query.js';
 import DreamTransaction from '../DreamTransaction.js';
@@ -63,14 +61,12 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * 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}.
      */
     static sync(connectionName: string, _: () => Promise<void> | void, options?: {
         schemaOnly?: boolean;
@@ -228,11 +224,16 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      * @param keys - the 64-bit signed lock keys, in acquisition order
      */
     static acquireAdvisoryTransactionLocks(txn: DreamTransaction<Dream>, keys: bigint[]): Promise<void>;
-    static getColumnData(connectionName: string, tableName: string, allTableAssociationData: {
-        [key: string]: SchemaBuilderAssociationData;
-    }): Promise<{
-        [key: string]: SchemaBuilderColumnData;
-    }>;
+    /**
+     * 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
+     */
+    static introspectDatabase(connectionName: string): Promise<IntrospectedDatabase>;
     /**
      * @internal
      *
@@ -542,9 +543,6 @@ export default class QueryDriverBase<DreamInstance extends Dream> {
      *   decide whether there is anything for the after-destroy hooks to act on.
      */
     static destroyDream(dream: Dream, txn: DreamTransaction<Dream>, reallyDestroy: boolean): Promise<number>;
-    static get syncDialect(): string;
-    /** @internal Resolve the credential used by the database type generator. */
-    static codegenPassword(password: DreamDbConfig['password']): Promise<string>;
     /**
      * Returns the sql that would be executed by this Query
      *

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

@@ -3,7 +3,6 @@ import { DeleteQueryBuilder, Kysely, Transaction as KyselyTransaction, OrderByIt
 import { DialectProviderCb } from '../../db/DreamDbConnection.js';
 import { DreamDbConfig } from '../../dream-app/index.js';
 import Dream from '../../Dream.js';
-import { SchemaBuilderInformationSchemaRow } from '../../helpers/cli/ASTBuilder.js';
 import { AssociationStatement, OrderQueryStatement } from '../../types/associations/shared.js';
 import { DbConnectionType, LegacyCompatiblePrimaryKeyType } from '../../types/db.js';
 import { DreamColumnNames, DreamTableSchema, OrderDir, SqlCommandType } from '../../types/dream.js';
@@ -58,8 +57,6 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
     static sync(connectionName: string, onSync: () => Promise<void> | void, options?: {
         schemaOnly?: boolean;
     }): Promise<void>;
-    static get syncDialect(): string;
-    static codegenPassword(password: DreamDbConfig['password']): Promise<string>;
     /**
      * @internal
      *
@@ -114,12 +111,6 @@ export default class KyselyQueryDriver<DreamInstance extends Dream> extends Quer
      * @returns void
      */
     static transaction<DreamInstance extends Dream, CB extends (txn: DreamTransaction<DreamInstance>) => unknown, RetType extends ReturnType<CB>>(dreamInstance: DreamInstance, callback: CB): Promise<RetType>;
-    /**
-     * @internal
-     *
-     * this is used by getColumnData to serialize enums
-     */
-    static enumType(row: SchemaBuilderInformationSchemaRow): Capitalize<string>;
     /**
      * @internal
      *

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

@@ -1,6 +1,6 @@
 import { type SelectQueryBuilder } from 'kysely';
 import Dream from '../../Dream.js';
-import { SchemaBuilderAssociationData, SchemaBuilderColumnData } from '../../helpers/cli/ASTBuilder.js';
+import { IntrospectedDatabase } from '../../types/db.js';
 import DreamTransaction from '../DreamTransaction.js';
 import KyselyQueryDriver from './Kysely.js';
 import type { TestDatabaseLockSession } from './Base.js';
@@ -25,16 +25,16 @@ export default class PostgresQueryDriver<DreamInstance extends Dream> extends Ky
      */
     static setDatabaseTypeParsers(connectionName: string): Promise<void>;
     /**
-     * @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 getColumnData(connectionName: string, tableName: string, allTableAssociationData: {
-        [key: string]: SchemaBuilderAssociationData;
-    }): Promise<{
-        [key: string]: SchemaBuilderColumnData;
-    }>;
+    static introspectDatabase(connectionName: string): Promise<IntrospectedDatabase>;
     static duplicateDatabase(connectionName: string): Promise<void>;
     /**
      * @internal

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

@@ -299,23 +299,23 @@ export interface DreamDbCredentialOptions {
     replica?: DreamDbConfig | undefined;
     queryDriverClass?: typeof QueryDriverBase;
     /**
-     * a string which informs the kysely-codegen tool,
-     * used to introspect tables under the hood, which tables to use.
-     * Can be an actual table name, or a glob pattern, i.e.
+     * The tables `sync` writes types for, when it should not be every table
+     * the connection can read. Every table it writes types for needs a Dream
+     * model. A table name, or a glob in Node's `path.matchesGlob` syntax,
+     * compared without regard to case, e.g.
+     *   "users"
+     *   "chalupas*"
      *   "public.*"
-     *   "public.+(user|post)"
+     *   "public.+(users|posts)"
      *
-     * see https://github.com/RobinBlomberg/kysely-codegen for more info
+     * A pattern that contains a `.` is matched against `<schema>.<table>`, and
+     * any other against the table's name alone.
      */
     tableIncludePattern?: string;
     /**
-     * a string which informs the kysely-codegen tool,
-     * used to introspect tables under the hood, which tables to use.
-     * Can be an actual table name, or a glob pattern, i.e.
-     *   "public.*"
-     *   "public.+(user|post)"
-     *
-     * see https://github.com/RobinBlomberg/kysely-codegen for more info
+     * The tables `sync` leaves out of the types it writes, e.g. tables that no
+     * Dream model reads. Written like `tableIncludePattern`, and applied after
+     * it.
      */
     tableExcludePattern?: string;
 }

package/dist/types/src/encrypt/InternalEncrypt.d.ts

@@ -1,6 +1,15 @@
 import { DecryptCallbacks } from './index.js';
 export default class InternalEncrypt {
     static encryptColumn(data: any): string | null;
+    /**
+     * 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: any, existingCiphertext: unknown): string | null;
     /**
      * Decrypts `data` with the column keys, current then legacy.
      * `onLegacyKeyUsed` is passed to `Encrypt.decrypt`, so it is called only

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

@@ -1,10 +1,11 @@
 import ts from 'typescript';
 import { DreamConst } from '../../dream/constants.js';
+import { IntrospectedValueType } from '../../types/db.js';
 /**
  * @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.
  *
@@ -18,61 +19,6 @@ export default class ASTBuilder {
      * builds a new line, useful for injecting new lines into AST statements
      */
     protected newLine(): ts.Identifier;
-    /**
-     * @internal
-     *
-     * given an interface declaration, it will extrace the relevant property statement
-     * by the given property name.
-     */
-    protected getPropertyFromInterface(interfaceNode: ts.InterfaceDeclaration, propertyName: string): ts.PropertySignature | 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
-     */
-    protected extractStringLiteralTypeNodesFromTypeOrUnion(typeAlias: ts.TypeAliasDeclaration): (ts.LiteralTypeNode & {
-        literal: {
-            text: string;
-        };
-    })[];
-    /**
-     * @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
-     */
-    protected extractTypeNodesFromTypeOrUnion(typeAlias: ts.TypeAliasDeclaration | ts.PropertySignature): ts.TypeNode[];
-    /**
-     * @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
-     */
-    protected exportedTypeAliasOrNull(node: ts.Node, exportName?: string): ts.TypeAliasDeclaration | 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
-     */
-    protected exportedInterfaceOrNull(node: ts.Node, exportName?: string): ts.InterfaceDeclaration | null;
-    /**
-     * @internal
-     *
-     * extracts the exportName from the provided dbSourceFile
-     */
-    protected findDbExport(dbSourceFile: ts.SourceFile, exportName: string): ts.Node | undefined;
     /**
      * @internal
      *
@@ -86,13 +32,6 @@ export default class ASTBuilder {
      * is not installed, then the original output is returned
      */
     protected prettier(output: string): Promise<string>;
-    /**
-     * @internal
-     *
-     * given a type node, it will send back the first found generic
-     * provided to that type.
-     */
-    protected getFirstGenericType(node: ts.Node): ts.TypeNode | null;
     /**
      * @internal
      *
@@ -103,13 +42,6 @@ export default class ASTBuilder {
      * import them both from @rvoh/dream.
      */
     protected dateAndDateTimeImports(): ts.ImportDeclaration[];
-    /**
-     * @internal
-     *
-     * for a given table name (i.e. balloon_lines), it will return the exported
-     * `BalloonLines` interface within the dbSourceFile
-     */
-    protected getTableInterfaceDeclaration(dbSourceFile: ts.SourceFile, tableName: string): ts.InterfaceDeclaration;
     /**
      * @internal
      *
@@ -122,32 +54,15 @@ export default class ASTBuilder {
      * checks if a database type is a date type (with optional array suffix)
      */
     protected isDateDbType(dbType: string): boolean;
-    /**
-     * @internal
-     *
-     * checks if a database type is a time without time zone type (with optional array suffix)
-     */
-    protected isTimeWithoutTimeZoneDbType(dbType: string): boolean;
-    /**
-     * @internal
-     *
-     * checks if a database type is a time with time zone type (with optional array suffix)
-     */
-    protected isTimeWithTimeZoneDbType(dbType: string): boolean;
-    /**
-     * @internal
-     *
-     * checks if a database type is any time type (with or without time zone, with optional array suffix)
-     */
-    protected isTimeDbType(dbType: string): boolean;
-    /**
-     * @internal
-     *
-     * checks if a TypeScript type node represents a string-like type
-     * (string keyword, string type reference, or string literal)
-     */
-    protected isStringLikeType(node: ts.TypeNode, sourceFile: ts.SourceFile): boolean;
 }
+/**
+ * @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 declare function propertyName(name: string): ts.Identifier | ts.StringLiteral;
 export interface SchemaData {
     [key: string]: TableData;
 }
@@ -176,15 +91,10 @@ export interface SchemaBuilderAssociationData {
 }
 export interface SchemaBuilderColumnData {
     dbType: string;
+    valueType: IntrospectedValueType;
     allowNull: boolean;
     enumType: string | null;
     enumValues: string | null;
     foreignKey: string | null;
     isArray: boolean;
 }
-export interface SchemaBuilderInformationSchemaRow {
-    columnName: string;
-    udtName: string;
-    dataType: string;
-    isNullable: 'YES' | 'NO';
-}

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

@@ -1,11 +1,11 @@
-import ts from 'typescript';
+import { IntrospectedDatabase, IntrospectedTable } from '../../types/db.js';
 import ASTBuilder, { SchemaData } from './ASTBuilder.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
@@ -15,63 +15,66 @@ import ASTBuilder, { SchemaData } from './ASTBuilder.js';
 export default class ASTConnectionBuilder extends ASTBuilder {
     protected connectionName: string;
     hasForeignKeyError: boolean;
-    constructor(connectionName: string);
+    private introspection;
+    private readonly introspectionFrom;
     /**
-     * @internal
-     *
-     * returns the path from project root to the dream.ts file
-     * for the particular connection. If the connectionName is anything
-     * other than default, the path will represent that by injecting
-     * the connectionName into the file name, i.e. dream.alternate.ts
+     * @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
      */
-    protected schemaPath(): string;
+    constructor(connectionName: string, opts?: {
+        introspectionFrom?: ASTConnectionBuilder | undefined;
+    });
     /**
      * @internal
      *
-     * returns the path from project root to the db.ts file
-     * for the particular connection. If the connectionName is anything
-     * other than default, the path will represent that by injecting
-     * the connectionName into the file name, i.e. db.alternate.ts
+     * 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.
      */
-    protected dbPath(): string;
+    protected introspectedDatabase(): Promise<IntrospectedDatabase>;
     /**
      * @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.
+     * the table's key in the DB interface and in Dream's schema: its name, or
+     * `<schema>.<name>` outside the connection's default schema
      */
-    protected getDbSourceFile(): Promise<ts.SourceFile>;
+    protected tableKey(table: IntrospectedTable): string;
     /**
      * @internal
      *
-     * reads the db source file for the given connection, returning the contents
-     * as a raw string
+     * 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
      */
-    protected loadDbSyncFile(): Promise<string>;
+    protected enumTypeNames(): Promise<Map<string, string>>;
     /**
      * @internal
      *
-     * builds up the schema data for every table into an object, which
-     * can be read and injected into AST nodes.
+     * returns the path from project root to the dream.ts file
+     * for the particular connection. If the connectionName is anything
+     * other than default, the path will represent that by injecting
+     * the connectionName into the file name, i.e. dream.alternate.ts
      */
-    protected getSchemaData(): Promise<SchemaData>;
+    protected schemaPath(): string;
     /**
      * @internal
      *
-     * used by getSchemaData to build up all table data
+     * returns the path from project root to the db.ts file
+     * for the particular connection. If the connectionName is anything
+     * other than default, the path will represent that by injecting
+     * the connectionName into the file name, i.e. db.alternate.ts
      */
-    private getTables;
+    protected dbPath(): string;
     /**
      * @internal
      *
-     * finds all enums used by the app, and returns information
-     * about those enums that can be used for type generating purpposes
+     * builds up the schema data for every table into an object, which
+     * can be read and injected into AST nodes.
      */
-    protected getAllEnumValueNames(): Promise<{
-        enumValues: string;
-        enumType: string;
-    }[]>;
+    protected getSchemaData(): Promise<SchemaData>;
     /**
      * @internal
      *
@@ -117,8 +120,8 @@ export default class ASTConnectionBuilder extends ASTBuilder {
     /**
      * @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
      */
-    private getColumnData;
+    private columnData;
 }

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

@@ -0,0 +1,26 @@
+import ASTConnectionBuilder from './ASTConnectionBuilder.js';
+/**
+ * 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 {
+    build(): Promise<void>;
+    /**
+     * @internal
+     *
+     * the table's columns, minus those its models ignore, sorted by name, each
+     * with its key (the camelized column name) and its type
+     */
+    private columns;
+    /**
+     * @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
+     */
+    private imports;
+}

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

@@ -60,21 +60,11 @@ export default class ASTSchemaBuilder extends ASTConnectionBuilder {
     /**
      * @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.
-     */
-    private getCoercedTypeForTableColumn;
-    /**
-     * @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
+     * 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.
      */
     private coercedType;
+    private coercedValueType;
 }

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

@@ -0,0 +1,37 @@
+import { IntrospectedTable } from '../../types/db.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 declare const PLAIN_ARRAY_VALUE_TYPES: string[];
+/**
+ * @internal
+ *
+ * The declaration of each type that types/db.ts declares for its columns.
+ */
+export declare const HELPER_TYPE_DECLARATIONS: Record<string, string>;
+/**
+ * @internal
+ *
+ * The types types/db.ts declares for the given tables' columns.
+ */
+export declare function dbTypesHelperNames(tables: IntrospectedTable[]): string[];
+/**
+ * @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 declare function dbTypesReservedNames(tables: IntrospectedTable[]): string[];
+/**
+ * @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 declare function dbTypesName(name: string, takenNames: Set<string>): string;

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

@@ -0,0 +1,15 @@
+/**
+ * @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: {
+    schema: string | null;
+    name: string;
+}, pattern: string): boolean;

package/dist/types/src/package-exports/types.d.ts

@@ -6,7 +6,7 @@ export { type SerializerRendererOpts } from '../serializer/SerializerRenderer.js
 export { type BelongsToStatement } from '../types/associations/belongsTo.js';
 export { type HasManyStatement } from '../types/associations/hasMany.js';
 export { type HasOneStatement } from '../types/associations/hasOne.js';
-export { type DbConnectionType, type DbTypes, type PrimaryKeyType } from '../types/db.js';
+export { type DbConnectionType, type DbTypes, type IntrospectedColumn, type IntrospectedDatabase, type IntrospectedEnum, type IntrospectedTable, type IntrospectedValueType, type PrimaryKeyType, } from '../types/db.js';
 export { type StrictInterface } from '../types/utils.js';
 export { type CalendarDateDurationUnit, type CalendarDateObject } from '../types/calendardate.js';
 export { type ClockTimeObject } from '../types/clocktime.js';