@mateusseiboth/ember-orm 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,288 @@
+import { S as SchemaDocument, M as ModelNode, F as FieldNode } from './index-D0xIdtCl.cjs';
+export { A as AttributeArgValue, D as DatasourceNode, c as DefaultValue, E as EnumNode, d as FieldKind, G as GeneratorNode, I as IndexNode, N as NativeType, R as ReferentialAction, e as RelationInfo, a as SCALAR_TYPES, b as ScalarType, U as UniqueIndex, f as emptySchema, g as fieldColumn, h as findEnum, i as findModel, j as idFields, m as modelTable, r as relationFields, s as scalarFields } from './index-D0xIdtCl.cjs';
+export { D as DatabaseError, E as EmberError, L as LoadedSchema, Q as QueryValidationError, R as RecordNotFoundError, S as SchemaParseError, a as SchemaValidationError, U as UniqueConstraintError, d as findSchemaPath, l as loadSchema, p as parseAndValidate, b as parseSchema, c as printSchema, r as resolveDatasourceUrl, v as validateSchema } from './index-CMeqhmVc.cjs';
+import { S as SqlDriver, C as ConnectionConfig, D as DriverOptions, T as TransactionContext, a as TransactionOptions, b as SqlValue, c as SqlDialect } from './index-CKqkQhZx.cjs';
+export { A as AggregateArgs, d as ClientOptions, e as CreateArgs, f as DeleteArgs, E as EmberClientBase, F as FindManyArgs, g as FindUniqueArgs, h as FirebirdDialect, G as GroupByArgs, I as IncludeInput, i as IsolationLevel, M as ModelDelegate, O as OrderByInput, Q as QueryEngine, j as SelectInput, U as UpdateArgs, k as UpsertArgs, W as WhereInput, l as createClient } from './index-CKqkQhZx.cjs';
+
+/**
+ * Firebird implementation of SqlDriver. Wraps node-firebird's callback API in
+ * promises, manages a connection pool, and guarantees every query executes
+ * inside a transaction. Nested `transaction()` calls reuse the active one via
+ * AsyncLocalStorage so `client.$transaction(...)` composes naturally.
+ */
+declare class FirebirdDriver implements SqlDriver {
+    private pool;
+    private readonly options;
+    private readonly poolMax;
+    private readonly onQuery?;
+    private readonly activeTx;
+    constructor(config: ConnectionConfig, driverOptions?: DriverOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    transaction<T>(fn: (tx: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    private acquire;
+    private begin;
+    private runOnTransaction;
+    private commit;
+    private safeRollback;
+}
+
+/**
+ * Parse a Firebird connection URL into a ConnectionConfig.
+ *
+ * Supported forms:
+ *   firebird://user:password@host:port/path/to/database.fdb?role=RDB$ADMIN
+ *   firebird://SYSDBA:masterkey@localhost:3050//var/lib/firebird/data/app.fdb
+ *
+ * The path after the host is treated as the absolute database path. A leading
+ * double slash (`//var/...`) yields an absolute POSIX path; a single slash with
+ * a Windows drive (`/C:/...`) is normalized too.
+ */
+declare function parseConnectionUrl(url: string): ConnectionConfig;
+declare function buildConnectionUrl(config: ConnectionConfig): string;
+
+/**
+ * Factory that builds a driver from either a connection URL or an explicit
+ * config object. Centralizing creation here keeps the client decoupled from a
+ * concrete driver class (Factory pattern / DIP).
+ */
+declare function createDriver(source: string | ConnectionConfig, options?: DriverOptions): SqlDriver;
+
+/**
+ * An accumulating SQL fragment that keeps text and bound parameters together,
+ * so values are always parameterized (`?`) and never string-interpolated.
+ * This is the core defense against SQL injection in the query layer.
+ */
+declare class Sql {
+    private parts;
+    readonly params: SqlValue[];
+    static raw(text: string): Sql;
+    static value(value: SqlValue): Sql;
+    static join(fragments: Sql[], separator: string): Sql;
+    /** Append raw, trusted SQL text (keywords, already-escaped identifiers). */
+    push(text: string): this;
+    /** Append a `?` placeholder bound to `value`. */
+    bind(value: SqlValue): this;
+    /** Append a comma-separated list of placeholders bound to `values`. */
+    bindList(values: readonly SqlValue[]): this;
+    /** Merge another fragment (text + params) into this one. */
+    append(other: Sql): this;
+    get text(): string;
+    isEmpty(): boolean;
+    toQuery(): {
+        sql: string;
+        params: SqlValue[];
+    };
+}
+
+interface IntrospectOptions {
+    datasource?: {
+        name: string;
+        provider: string;
+        envVar?: string;
+        url?: string;
+    };
+}
+/**
+ * Reverse-engineer a SchemaDocument from a live Firebird database.
+ * Table/column names are kept as-is via `@@map`/`@map` when the idiomatic
+ * Ember name differs, and foreign keys become relation fields on both sides.
+ */
+declare class Introspector {
+    private readonly driver;
+    constructor(driver: SqlDriver);
+    introspect(options?: IntrospectOptions): Promise<SchemaDocument>;
+    private buildModel;
+}
+
+/**
+ * Generates a fully-typed TypeScript client from a schema. Produces per-model
+ * scalar types, relation payloads, filter/where/select/include/create/update
+ * input types, typed delegates, and the `EmberClient` class (which embeds the
+ * schema so it can run with no extra wiring).
+ */
+declare class ClientGenerator {
+    private readonly schema;
+    constructor(schema: SchemaDocument);
+    generate(): string;
+    private header;
+    private enums;
+    private enumType;
+    private modelTypes;
+    private modelType;
+    /**
+     * Fluent-API return type for single-record reads: a Promise of the payload
+     * that also exposes a method per relation (to-many -> array; to-one ->
+     * chainable fluent).
+     */
+    private fluentType;
+    /**
+     * Type-level registry powering recursive payload resolution: a model-name
+     * union, a scalar-payload map, and a relation map carrying each relation's
+     * target model, list-ness and nullability.
+     */
+    private registry;
+    private scalarType;
+    private namespace;
+    private whereInput;
+    private whereUnique;
+    private fieldFilter;
+    private relationFilter;
+    private orderByInput;
+    private selectInclude;
+    private dataInputs;
+    private inputScalarType;
+    /**
+     * Update value for a scalar field: a bare value, `{ set }`, and — for numeric
+     * fields — the atomic operators increment/decrement/multiply/divide.
+     */
+    private updateScalarType;
+    private nestedCreate;
+    private nestedUpdate;
+    private argsTypes;
+    private delegateInterface;
+    private clientClass;
+}
+declare function generateClientSource(schema: SchemaDocument): string;
+/** Generate and write the client to `<outDir>/index.ts`. Returns the path. */
+declare function writeClient(schema: SchemaDocument, outDir: string): string;
+
+interface ColumnChange {
+    field: FieldNode;
+    table: string;
+    typeChanged: boolean;
+    nullabilityChanged: boolean;
+}
+interface UniqueSpec {
+    name: string;
+    columns: string[];
+}
+interface ForeignKeySpec {
+    name: string;
+    columns: string[];
+    refTable: string;
+    refColumns: string[];
+    onDelete?: string;
+    onUpdate?: string;
+}
+interface ModelChange {
+    model: ModelNode;
+    table: string;
+    addedColumns: FieldNode[];
+    droppedColumns: string[];
+    changedColumns: ColumnChange[];
+    addedUniques: UniqueSpec[];
+    addedForeignKeys: ForeignKeySpec[];
+}
+interface SchemaDiff {
+    createdModels: ModelNode[];
+    droppedTables: string[];
+    modelChanges: ModelChange[];
+}
+/**
+ * Structural diff turning `current` (usually introspected from the live DB)
+ * into `desired` (the `.ember` schema). Pure and dialect-independent; the
+ * planner converts it to DDL.
+ *
+ * Scope (safe subset): create/drop tables, add/drop/alter columns, and add
+ * unique/foreign-key constraints that don't already exist. Dropping
+ * constraints and plain (non-constraint) indexes on existing tables is left to
+ * explicit user action — see doc/migrations.md.
+ */
+declare function diffSchemas(desired: SchemaDocument, current: SchemaDocument): SchemaDiff;
+
+/**
+ * Convert a SchemaDiff into an ordered list of DDL statements. Order matters in
+ * Firebird: tables and columns must exist before constraints reference them, so
+ * foreign keys are always emitted last.
+ */
+declare function planMigration(diff: SchemaDiff, desired: SchemaDocument, dialect: SqlDialect): string[];
+/** Render DDL statements as a `.sql` migration file body. */
+declare function renderMigrationSql(statements: string[]): string;
+/** Split a migration `.sql` body back into executable statements. */
+declare function splitStatements(sql: string): string[];
+
+/**
+ * Generates Firebird DDL from schema nodes. Pure string generation (no I/O),
+ * so it is fully unit-testable. Identifier quoting is delegated to the dialect
+ * (Strategy) to stay backend-agnostic at the call sites.
+ */
+declare class FirebirdDdl {
+    private readonly d;
+    constructor(d: SqlDialect);
+    /** Firebird column type for a field, honoring its `@db.*` native type. */
+    columnType(field: FieldNode): string;
+    /** `"COL" <type> [GENERATED ...] [DEFAULT ...] [NOT NULL]`. */
+    columnDefinition(field: FieldNode): string;
+    /**
+     * On Firebird 2.1/2.5 (no IDENTITY), emulate autoincrement with a SEQUENCE
+     * and a BEFORE INSERT trigger. Returns the extra DDL objects to create after
+     * the table; an empty array when IDENTITY is supported.
+     */
+    autoIncrementObjects(model: ModelNode): string[];
+    autoIncrementForColumn(table: string, column: string): string[];
+    createTable(model: ModelNode): string;
+    dropTable(table: string): string;
+    addColumn(table: string, field: FieldNode): string;
+    dropColumn(table: string, column: string): string;
+    /** Change a column's data type (Firebird: ALTER COLUMN ... TYPE ...). */
+    alterColumnType(table: string, field: FieldNode): string;
+    setNotNull(table: string, column: string, notNull: boolean): string;
+    addUnique(table: string, name: string, columns: string[]): string;
+    dropConstraint(table: string, name: string): string;
+    addForeignKey(table: string, name: string, columns: string[], refTable: string, refColumns: string[], onDelete?: string, onUpdate?: string): string;
+    createIndex(table: string, name: string, columns: string[], unique: boolean): string;
+    dropIndex(name: string): string;
+}
+
+interface DevResult {
+    empty: boolean;
+    id?: string;
+    dir?: string;
+    statements: string[];
+}
+interface DeployResult {
+    applied: {
+        id: string;
+        steps: number;
+    }[];
+}
+interface StatusResult {
+    applied: string[];
+    pending: string[];
+}
+/**
+ * Drives schema migrations against a live Firebird database. Diffs the desired
+ * `.ember` schema against the introspected current state and emits/applies DDL.
+ * The history table `_EMBER_MIGRATIONS` is always excluded from the diff.
+ */
+declare class Migrator {
+    private readonly driver;
+    private readonly desired;
+    private readonly migrationsDir;
+    private readonly dialect;
+    constructor(driver: SqlDriver, desired: SchemaDocument, migrationsDir: string, dialect?: SqlDialect);
+    /** Compute the diff between the desired schema and the live database. */
+    diff(): Promise<SchemaDiff>;
+    /** Plan (but do not apply) the DDL needed to reach the desired schema. */
+    plan(): Promise<string[]>;
+    /**
+     * `migrate dev`: create a timestamped migration from the current diff, apply
+     * it, and record it in history.
+     */
+    dev(name?: string): Promise<DevResult>;
+    /**
+     * `db push`: apply the diff directly to the database without writing a
+     * migration file (prototyping flow).
+     */
+    push(): Promise<{
+        statements: string[];
+    }>;
+    /** `migrate deploy`: apply every on-disk migration not yet recorded. */
+    deploy(): Promise<DeployResult>;
+    /** `migrate status`: list applied vs pending migrations. */
+    status(): Promise<StatusResult>;
+    private currentSchema;
+}
+
+export { ClientGenerator, ConnectionConfig, FieldNode, FirebirdDdl, FirebirdDriver, Introspector, Migrator, ModelNode, SchemaDocument, Sql, SqlDialect, SqlDriver, SqlValue, TransactionContext, TransactionOptions, buildConnectionUrl, createDriver, diffSchemas, generateClientSource, parseConnectionUrl, planMigration, renderMigrationSql, splitStatements, writeClient };

package/dist/index.d.ts

@@ -0,0 +1,288 @@
+import { S as SchemaDocument, M as ModelNode, F as FieldNode } from './index-D0xIdtCl.js';
+export { A as AttributeArgValue, D as DatasourceNode, c as DefaultValue, E as EnumNode, d as FieldKind, G as GeneratorNode, I as IndexNode, N as NativeType, R as ReferentialAction, e as RelationInfo, a as SCALAR_TYPES, b as ScalarType, U as UniqueIndex, f as emptySchema, g as fieldColumn, h as findEnum, i as findModel, j as idFields, m as modelTable, r as relationFields, s as scalarFields } from './index-D0xIdtCl.js';
+export { D as DatabaseError, E as EmberError, L as LoadedSchema, Q as QueryValidationError, R as RecordNotFoundError, S as SchemaParseError, a as SchemaValidationError, U as UniqueConstraintError, d as findSchemaPath, l as loadSchema, p as parseAndValidate, b as parseSchema, c as printSchema, r as resolveDatasourceUrl, v as validateSchema } from './index-0lWi8TMM.js';
+import { S as SqlDriver, C as ConnectionConfig, D as DriverOptions, T as TransactionContext, a as TransactionOptions, b as SqlValue, c as SqlDialect } from './index-BSXZjDUd.js';
+export { A as AggregateArgs, d as ClientOptions, e as CreateArgs, f as DeleteArgs, E as EmberClientBase, F as FindManyArgs, g as FindUniqueArgs, h as FirebirdDialect, G as GroupByArgs, I as IncludeInput, i as IsolationLevel, M as ModelDelegate, O as OrderByInput, Q as QueryEngine, j as SelectInput, U as UpdateArgs, k as UpsertArgs, W as WhereInput, l as createClient } from './index-BSXZjDUd.js';
+
+/**
+ * Firebird implementation of SqlDriver. Wraps node-firebird's callback API in
+ * promises, manages a connection pool, and guarantees every query executes
+ * inside a transaction. Nested `transaction()` calls reuse the active one via
+ * AsyncLocalStorage so `client.$transaction(...)` composes naturally.
+ */
+declare class FirebirdDriver implements SqlDriver {
+    private pool;
+    private readonly options;
+    private readonly poolMax;
+    private readonly onQuery?;
+    private readonly activeTx;
+    constructor(config: ConnectionConfig, driverOptions?: DriverOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    transaction<T>(fn: (tx: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
+    private acquire;
+    private begin;
+    private runOnTransaction;
+    private commit;
+    private safeRollback;
+}
+
+/**
+ * Parse a Firebird connection URL into a ConnectionConfig.
+ *
+ * Supported forms:
+ *   firebird://user:password@host:port/path/to/database.fdb?role=RDB$ADMIN
+ *   firebird://SYSDBA:masterkey@localhost:3050//var/lib/firebird/data/app.fdb
+ *
+ * The path after the host is treated as the absolute database path. A leading
+ * double slash (`//var/...`) yields an absolute POSIX path; a single slash with
+ * a Windows drive (`/C:/...`) is normalized too.
+ */
+declare function parseConnectionUrl(url: string): ConnectionConfig;
+declare function buildConnectionUrl(config: ConnectionConfig): string;
+
+/**
+ * Factory that builds a driver from either a connection URL or an explicit
+ * config object. Centralizing creation here keeps the client decoupled from a
+ * concrete driver class (Factory pattern / DIP).
+ */
+declare function createDriver(source: string | ConnectionConfig, options?: DriverOptions): SqlDriver;
+
+/**
+ * An accumulating SQL fragment that keeps text and bound parameters together,
+ * so values are always parameterized (`?`) and never string-interpolated.
+ * This is the core defense against SQL injection in the query layer.
+ */
+declare class Sql {
+    private parts;
+    readonly params: SqlValue[];
+    static raw(text: string): Sql;
+    static value(value: SqlValue): Sql;
+    static join(fragments: Sql[], separator: string): Sql;
+    /** Append raw, trusted SQL text (keywords, already-escaped identifiers). */
+    push(text: string): this;
+    /** Append a `?` placeholder bound to `value`. */
+    bind(value: SqlValue): this;
+    /** Append a comma-separated list of placeholders bound to `values`. */
+    bindList(values: readonly SqlValue[]): this;
+    /** Merge another fragment (text + params) into this one. */
+    append(other: Sql): this;
+    get text(): string;
+    isEmpty(): boolean;
+    toQuery(): {
+        sql: string;
+        params: SqlValue[];
+    };
+}
+
+interface IntrospectOptions {
+    datasource?: {
+        name: string;
+        provider: string;
+        envVar?: string;
+        url?: string;
+    };
+}
+/**
+ * Reverse-engineer a SchemaDocument from a live Firebird database.
+ * Table/column names are kept as-is via `@@map`/`@map` when the idiomatic
+ * Ember name differs, and foreign keys become relation fields on both sides.
+ */
+declare class Introspector {
+    private readonly driver;
+    constructor(driver: SqlDriver);
+    introspect(options?: IntrospectOptions): Promise<SchemaDocument>;
+    private buildModel;
+}
+
+/**
+ * Generates a fully-typed TypeScript client from a schema. Produces per-model
+ * scalar types, relation payloads, filter/where/select/include/create/update
+ * input types, typed delegates, and the `EmberClient` class (which embeds the
+ * schema so it can run with no extra wiring).
+ */
+declare class ClientGenerator {
+    private readonly schema;
+    constructor(schema: SchemaDocument);
+    generate(): string;
+    private header;
+    private enums;
+    private enumType;
+    private modelTypes;
+    private modelType;
+    /**
+     * Fluent-API return type for single-record reads: a Promise of the payload
+     * that also exposes a method per relation (to-many -> array; to-one ->
+     * chainable fluent).
+     */
+    private fluentType;
+    /**
+     * Type-level registry powering recursive payload resolution: a model-name
+     * union, a scalar-payload map, and a relation map carrying each relation's
+     * target model, list-ness and nullability.
+     */
+    private registry;
+    private scalarType;
+    private namespace;
+    private whereInput;
+    private whereUnique;
+    private fieldFilter;
+    private relationFilter;
+    private orderByInput;
+    private selectInclude;
+    private dataInputs;
+    private inputScalarType;
+    /**
+     * Update value for a scalar field: a bare value, `{ set }`, and — for numeric
+     * fields — the atomic operators increment/decrement/multiply/divide.
+     */
+    private updateScalarType;
+    private nestedCreate;
+    private nestedUpdate;
+    private argsTypes;
+    private delegateInterface;
+    private clientClass;
+}
+declare function generateClientSource(schema: SchemaDocument): string;
+/** Generate and write the client to `<outDir>/index.ts`. Returns the path. */
+declare function writeClient(schema: SchemaDocument, outDir: string): string;
+
+interface ColumnChange {
+    field: FieldNode;
+    table: string;
+    typeChanged: boolean;
+    nullabilityChanged: boolean;
+}
+interface UniqueSpec {
+    name: string;
+    columns: string[];
+}
+interface ForeignKeySpec {
+    name: string;
+    columns: string[];
+    refTable: string;
+    refColumns: string[];
+    onDelete?: string;
+    onUpdate?: string;
+}
+interface ModelChange {
+    model: ModelNode;
+    table: string;
+    addedColumns: FieldNode[];
+    droppedColumns: string[];
+    changedColumns: ColumnChange[];
+    addedUniques: UniqueSpec[];
+    addedForeignKeys: ForeignKeySpec[];
+}
+interface SchemaDiff {
+    createdModels: ModelNode[];
+    droppedTables: string[];
+    modelChanges: ModelChange[];
+}
+/**
+ * Structural diff turning `current` (usually introspected from the live DB)
+ * into `desired` (the `.ember` schema). Pure and dialect-independent; the
+ * planner converts it to DDL.
+ *
+ * Scope (safe subset): create/drop tables, add/drop/alter columns, and add
+ * unique/foreign-key constraints that don't already exist. Dropping
+ * constraints and plain (non-constraint) indexes on existing tables is left to
+ * explicit user action — see doc/migrations.md.
+ */
+declare function diffSchemas(desired: SchemaDocument, current: SchemaDocument): SchemaDiff;
+
+/**
+ * Convert a SchemaDiff into an ordered list of DDL statements. Order matters in
+ * Firebird: tables and columns must exist before constraints reference them, so
+ * foreign keys are always emitted last.
+ */
+declare function planMigration(diff: SchemaDiff, desired: SchemaDocument, dialect: SqlDialect): string[];
+/** Render DDL statements as a `.sql` migration file body. */
+declare function renderMigrationSql(statements: string[]): string;
+/** Split a migration `.sql` body back into executable statements. */
+declare function splitStatements(sql: string): string[];
+
+/**
+ * Generates Firebird DDL from schema nodes. Pure string generation (no I/O),
+ * so it is fully unit-testable. Identifier quoting is delegated to the dialect
+ * (Strategy) to stay backend-agnostic at the call sites.
+ */
+declare class FirebirdDdl {
+    private readonly d;
+    constructor(d: SqlDialect);
+    /** Firebird column type for a field, honoring its `@db.*` native type. */
+    columnType(field: FieldNode): string;
+    /** `"COL" <type> [GENERATED ...] [DEFAULT ...] [NOT NULL]`. */
+    columnDefinition(field: FieldNode): string;
+    /**
+     * On Firebird 2.1/2.5 (no IDENTITY), emulate autoincrement with a SEQUENCE
+     * and a BEFORE INSERT trigger. Returns the extra DDL objects to create after
+     * the table; an empty array when IDENTITY is supported.
+     */
+    autoIncrementObjects(model: ModelNode): string[];
+    autoIncrementForColumn(table: string, column: string): string[];
+    createTable(model: ModelNode): string;
+    dropTable(table: string): string;
+    addColumn(table: string, field: FieldNode): string;
+    dropColumn(table: string, column: string): string;
+    /** Change a column's data type (Firebird: ALTER COLUMN ... TYPE ...). */
+    alterColumnType(table: string, field: FieldNode): string;
+    setNotNull(table: string, column: string, notNull: boolean): string;
+    addUnique(table: string, name: string, columns: string[]): string;
+    dropConstraint(table: string, name: string): string;
+    addForeignKey(table: string, name: string, columns: string[], refTable: string, refColumns: string[], onDelete?: string, onUpdate?: string): string;
+    createIndex(table: string, name: string, columns: string[], unique: boolean): string;
+    dropIndex(name: string): string;
+}
+
+interface DevResult {
+    empty: boolean;
+    id?: string;
+    dir?: string;
+    statements: string[];
+}
+interface DeployResult {
+    applied: {
+        id: string;
+        steps: number;
+    }[];
+}
+interface StatusResult {
+    applied: string[];
+    pending: string[];
+}
+/**
+ * Drives schema migrations against a live Firebird database. Diffs the desired
+ * `.ember` schema against the introspected current state and emits/applies DDL.
+ * The history table `_EMBER_MIGRATIONS` is always excluded from the diff.
+ */
+declare class Migrator {
+    private readonly driver;
+    private readonly desired;
+    private readonly migrationsDir;
+    private readonly dialect;
+    constructor(driver: SqlDriver, desired: SchemaDocument, migrationsDir: string, dialect?: SqlDialect);
+    /** Compute the diff between the desired schema and the live database. */
+    diff(): Promise<SchemaDiff>;
+    /** Plan (but do not apply) the DDL needed to reach the desired schema. */
+    plan(): Promise<string[]>;
+    /**
+     * `migrate dev`: create a timestamped migration from the current diff, apply
+     * it, and record it in history.
+     */
+    dev(name?: string): Promise<DevResult>;
+    /**
+     * `db push`: apply the diff directly to the database without writing a
+     * migration file (prototyping flow).
+     */
+    push(): Promise<{
+        statements: string[];
+    }>;
+    /** `migrate deploy`: apply every on-disk migration not yet recorded. */
+    deploy(): Promise<DeployResult>;
+    /** `migrate status`: list applied vs pending migrations. */
+    status(): Promise<StatusResult>;
+    private currentSchema;
+}
+
+export { ClientGenerator, ConnectionConfig, FieldNode, FirebirdDdl, FirebirdDriver, Introspector, Migrator, ModelNode, SchemaDocument, Sql, SqlDialect, SqlDriver, SqlValue, TransactionContext, TransactionOptions, buildConnectionUrl, createDriver, diffSchemas, generateClientSource, parseConnectionUrl, planMigration, renderMigrationSql, splitStatements, writeClient };