@jxsuite/connector 0.1.0

package/src/dialects/bun-sqlite.ts

@@ -0,0 +1,130 @@
+/**
+ * Bun-sqlite dialect — a minimal Kysely dialect over `bun:sqlite`.
+ *
+ * Backs the Sqlite connector and the dev server's `local: "sqlite"` stand-ins. The database opens
+ * lazily inside `Driver.init()` (creating the parent directory when a file path is given), so
+ * constructing the dialect stays synchronous and side-effect-free; tests and embedded hosts may
+ * inject an already-open database instead. `bun:sqlite` is imported dynamically through an opaque
+ * specifier so browser/worker bundles that merely reach this module's importers never try to
+ * resolve it.
+ */
+
+import { CompiledQuery, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from "kysely";
+import type { SQLQueryBindings } from "bun:sqlite";
+import type { DatabaseConnection, Dialect, Driver, QueryResult } from "kysely";
+
+/** The subset of `bun:sqlite`'s Statement the driver uses (type-only import — erased). */
+export interface BunSqliteStatementLike {
+  columnNames: string[];
+  all: (...params: SQLQueryBindings[]) => unknown[];
+  run: (...params: SQLQueryBindings[]) => { changes: number; lastInsertRowid: number | bigint };
+}
+
+/** The subset of `bun:sqlite`'s Database the driver uses. */
+export interface BunSqliteDatabaseLike {
+  prepare: (sql: string) => BunSqliteStatementLike;
+  close?: () => void;
+}
+
+export interface BunSqliteDialectConfig {
+  /** SQLite file path (":memory:" for in-memory). Ignored when `database` is injected. */
+  url?: string;
+  /** An already-open database — the dialect will not close it on destroy. */
+  database?: BunSqliteDatabaseLike;
+}
+
+/**
+ * Create the Kysely dialect.
+ *
+ * @param {BunSqliteDialectConfig} [config]
+ * @returns {Dialect}
+ */
+export function createBunSqliteDialect(config: BunSqliteDialectConfig = {}): Dialect {
+  return {
+    createAdapter: () => new SqliteAdapter(),
+    createDriver: () => createDriver(config),
+    createIntrospector: (db) => new SqliteIntrospector(db),
+    createQueryCompiler: () => new SqliteQueryCompiler(),
+  };
+}
+
+/** Open the configured database (dynamic imports keep this module bundle-inert). */
+async function openDatabase(config: BunSqliteDialectConfig): Promise<{
+  db: BunSqliteDatabaseLike;
+  owned: boolean;
+}> {
+  const { database, url } = config;
+  if (database) {
+    return { db: database, owned: false };
+  }
+  const file = url ?? ":memory:";
+  if (file !== ":memory:") {
+    // Ensure the parent directory exists (dev-server convention: <project>/.jx/data/).
+    const fsSpecifier = "node:fs";
+    const pathSpecifier = "node:path";
+    const fs = (await import(fsSpecifier)) as {
+      mkdirSync: (path: string, options: { recursive: boolean }) => void;
+    };
+    const path = (await import(pathSpecifier)) as { dirname: (path: string) => string };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+  }
+  const sqliteSpecifier = "bun:sqlite";
+  const sqlite = (await import(sqliteSpecifier)) as {
+    Database: new (file: string) => BunSqliteDatabaseLike;
+  };
+  return { db: new sqlite.Database(file), owned: true };
+}
+
+/** Build the single-connection driver over one bun:sqlite database. */
+function createDriver(config: BunSqliteDialectConfig): Driver {
+  let db: BunSqliteDatabaseLike | null = null;
+  let owned = false;
+
+  const connection: DatabaseConnection = {
+    executeQuery: async <R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>> => {
+      if (!db) {
+        throw new Error("BunSqliteDialect used before init()");
+      }
+      const { sql, parameters } = compiledQuery;
+      const stmt = db.prepare(sql);
+      const bindings = parameters as SQLQueryBindings[];
+      if (stmt.columnNames.length > 0) {
+        return { rows: stmt.all(...bindings) as R[] };
+      }
+      const info = stmt.run(...bindings);
+      return {
+        insertId: BigInt(info.lastInsertRowid),
+        numAffectedRows: BigInt(info.changes),
+        rows: [],
+      };
+    },
+    streamQuery: () => {
+      throw new Error("BunSqliteDialect does not support streaming");
+    },
+  };
+
+  return {
+    acquireConnection: async () => connection,
+    beginTransaction: async (conn) => {
+      await conn.executeQuery(CompiledQuery.raw("begin"));
+    },
+    commitTransaction: async (conn) => {
+      await conn.executeQuery(CompiledQuery.raw("commit"));
+    },
+    destroy: async () => {
+      if (owned) {
+        db?.close?.();
+      }
+      db = null;
+    },
+    init: async () => {
+      ({ db, owned } = await openDatabase(config));
+    },
+    releaseConnection: async () => {
+      // Single-connection driver — nothing to release.
+    },
+    rollbackTransaction: async (conn) => {
+      await conn.executeQuery(CompiledQuery.raw("rollback"));
+    },
+  };
+}

package/src/dialects/d1-http.ts

@@ -0,0 +1,113 @@
+/**
+ * D1-http dialect — Kysely over Cloudflare's D1 HTTP API.
+ *
+ * Used where no D1 binding exists: `jx db push` from a developer machine, connection tests, and
+ * compiler-timing SSG bakes. Every query POSTs to the accounts/{account}/d1/database/{database}
+ * /query endpoint with a `CLOUDFLARE_API_TOKEN` bearer. Inside deployed Workers the kysely-d1
+ * binding dialect is used instead (see d1.ts).
+ */
+
+import { SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler } from "kysely";
+import type { CompiledQuery, DatabaseConnection, Dialect, Driver, QueryResult } from "kysely";
+
+export interface D1HttpDialectConfig {
+  accountId: string;
+  databaseId: string;
+  apiToken: string;
+  /** Injected fetch (tests); defaults to globalThis.fetch. */
+  fetch?: typeof globalThis.fetch;
+  /** API origin override; defaults to https://api.cloudflare.com. */
+  baseUrl?: string;
+}
+
+interface D1HttpResponse {
+  success?: boolean;
+  errors?: { code?: number; message?: string }[];
+  result?: {
+    success?: boolean;
+    results?: Record<string, unknown>[];
+    meta?: { changes?: number; last_row_id?: number };
+  }[];
+}
+
+/**
+ * Create the Kysely dialect over the D1 HTTP API.
+ *
+ * @param {D1HttpDialectConfig} config
+ * @returns {Dialect}
+ */
+export function createD1HttpDialect(config: D1HttpDialectConfig): Dialect {
+  return {
+    createAdapter: () => new SqliteAdapter(),
+    createDriver: () => createDriver(config),
+    createIntrospector: (db) => new SqliteIntrospector(db),
+    createQueryCompiler: () => new SqliteQueryCompiler(),
+  };
+}
+
+/** Execute one SQL statement against the HTTP endpoint. */
+async function executeHttp<R>(
+  config: D1HttpDialectConfig,
+  sql: string,
+  parameters: readonly unknown[],
+): Promise<QueryResult<R>> {
+  const { accountId, databaseId, apiToken, baseUrl = "https://api.cloudflare.com" } = config;
+  const doFetch = config.fetch ?? globalThis.fetch;
+  const url = `${baseUrl}/client/v4/accounts/${accountId}/d1/database/${databaseId}/query`;
+  const response = await doFetch(url, {
+    body: JSON.stringify({ params: parameters, sql }),
+    headers: {
+      Authorization: `Bearer ${apiToken}`,
+      "Content-Type": "application/json",
+    },
+    method: "POST",
+  });
+  const body = (await response.json().catch(() => null)) as D1HttpResponse | null;
+  if (!response.ok || !body?.success) {
+    const detail =
+      body?.errors
+        ?.map((e) => e.message)
+        .filter(Boolean)
+        .join("; ") || `HTTP ${response.status}`;
+    throw new Error(`D1 HTTP API error: ${detail}`);
+  }
+  const [result] = body.result ?? [];
+  const meta = result?.meta ?? {};
+  return {
+    ...(meta.last_row_id === undefined ? {} : { insertId: BigInt(meta.last_row_id) }),
+    ...(meta.changes === undefined ? {} : { numAffectedRows: BigInt(meta.changes) }),
+    rows: (result?.results ?? []) as R[],
+  };
+}
+
+/** Build the stateless HTTP driver. */
+function createDriver(config: D1HttpDialectConfig): Driver {
+  const connection: DatabaseConnection = {
+    executeQuery: <R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>> =>
+      executeHttp<R>(config, compiledQuery.sql, compiledQuery.parameters),
+    streamQuery: () => {
+      throw new Error("D1HttpDialect does not support streaming");
+    },
+  };
+  return {
+    acquireConnection: async () => connection,
+    beginTransaction: async () => {
+      // The HTTP API is per-statement; transactions are not supported.
+    },
+    commitTransaction: async () => {
+      // See beginTransaction.
+    },
+    destroy: async () => {
+      // Stateless — nothing to close.
+    },
+    init: async () => {
+      // Stateless — nothing to open.
+    },
+    releaseConnection: async () => {
+      // Stateless — nothing to release.
+    },
+    rollbackTransaction: async () => {
+      throw new Error("D1HttpDialect cannot roll back (no transaction support)");
+    },
+  };
+}

package/src/provider-utils.ts

@@ -0,0 +1,86 @@
+/**
+ * Provider-utils — shared machinery behind the connector capability methods.
+ *
+ * Each provider (d1, supabase, sqlite) resolves a Kysely dialect its own way; deploySchema and
+ * testConnection are then identical: open Kysely over the dialect, run the additive sync (or a
+ * probe select), and always destroy the instance. Kept separate from connectors.ts so the provider
+ * modules can share it without an import cycle.
+ */
+
+import { Kysely, sql } from "kysely";
+import { syncTables } from "./ddl.ts";
+import type { Dialect } from "kysely";
+import type { SqlDialectKind } from "./columns.ts";
+import type { DynamicDatabase } from "./query.ts";
+import type { ConnectionDef, DeploySchemaResult, TableDef, TestConnectionResult } from "./types.ts";
+
+/** The static capability surface of a connector provider implementation. */
+export interface ConnectorProvider {
+  kind: SqlDialectKind;
+  dialect: (connection: ConnectionDef, env: Record<string, unknown>) => Dialect | Promise<Dialect>;
+  deploySchema: (
+    tables: Record<string, TableDef>,
+    connection: ConnectionDef,
+    options: { env: Record<string, unknown>; dryRun?: boolean },
+  ) => Promise<DeploySchemaResult>;
+  bindings: (connection: ConnectionDef) => Record<string, unknown>;
+  testConnection: (
+    connection: ConnectionDef,
+    env: Record<string, unknown>,
+  ) => Promise<TestConnectionResult>;
+}
+
+/**
+ * Run the additive schema sync over a dialect, always destroying the Kysely instance.
+ *
+ * @param {Dialect} dialect
+ * @param {SqlDialectKind} kind
+ * @param {Record<string, TableDef>} tables
+ * @param {{ dryRun?: boolean }} [options]
+ * @returns {Promise<DeploySchemaResult>}
+ */
+export async function deployWithDialect(
+  dialect: Dialect,
+  kind: SqlDialectKind,
+  tables: Record<string, TableDef>,
+  options: { dryRun?: boolean } = {},
+): Promise<DeploySchemaResult> {
+  const db = new Kysely<DynamicDatabase>({ dialect });
+  try {
+    return await syncTables(db, tables, { dialect: kind, dryRun: options.dryRun ?? false });
+  } finally {
+    await db.destroy();
+  }
+}
+
+/**
+ * Probe a dialect with `select 1`.
+ *
+ * @param {Dialect} dialect
+ * @returns {Promise<TestConnectionResult>}
+ */
+export async function testWithDialect(dialect: Dialect): Promise<TestConnectionResult> {
+  const db = new Kysely<DynamicDatabase>({ dialect });
+  try {
+    await sql`select 1`.execute(db);
+    return { ok: true };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error), ok: false };
+  } finally {
+    await db.destroy();
+  }
+}
+
+/** The tables of one connection (a data section filtered by connection name). */
+export function tablesForConnection(
+  tables: Record<string, TableDef>,
+  connectionName: string,
+): Record<string, TableDef> {
+  const out: Record<string, TableDef> = {};
+  for (const [name, def] of Object.entries(tables)) {
+    if (def.connection === connectionName) {
+      out[name] = def;
+    }
+  }
+  return out;
+}

package/src/query.ts

@@ -0,0 +1,199 @@
+/**
+ * Query — the content filter grammar over Kysely.
+ *
+ * Dynamic tables answer the same filter/sort/limit grammar content collections use
+ * (`@jxsuite/parser/content`): a filter is an array of `{ field, op, value }` rules (or an object
+ * shorthand of equality pairs), sort is `{ field, order }` (or a list), and every rule must match
+ * (AND). This module translates those rules into `where()` expressions with the same semantics the
+ * in-memory evaluator has — including `!=` matching NULL and `empty` treating '' and '[]' as
+ * empty.
+ */
+
+import type { ExpressionBuilder, ExpressionWrapper, SelectQueryBuilder, SqlBool } from "kysely";
+import type { ColumnSpec } from "./columns.ts";
+
+/** One filter rule of the shared content grammar. */
+export interface FilterRule {
+  field: string;
+  op: string;
+  value?: unknown;
+}
+
+export interface SortRule {
+  field: string;
+  order?: string;
+}
+
+/** Loosely-typed database shape for dynamic tables (columns are only known at runtime). */
+export type DynamicDatabase = Record<string, Record<string, unknown>>;
+
+type DynamicSelect = SelectQueryBuilder<DynamicDatabase, string, Record<string, unknown>>;
+type DynamicEb = ExpressionBuilder<DynamicDatabase, string>;
+type BoolExpr = ExpressionWrapper<DynamicDatabase, string, SqlBool>;
+
+/**
+ * Normalize a wire filter (rule array or equality-object shorthand) into rules.
+ *
+ * @param {unknown} filter
+ * @returns {FilterRule[]}
+ */
+export function normalizeFilter(filter: unknown): FilterRule[] {
+  if (Array.isArray(filter)) {
+    return (filter as FilterRule[]).filter(
+      (rule) => rule && typeof rule === "object" && typeof rule.field === "string",
+    );
+  }
+  if (filter && typeof filter === "object") {
+    return Object.entries(filter as Record<string, unknown>).map(([field, value]) => ({
+      field,
+      op: "==",
+      value,
+    }));
+  }
+  return [];
+}
+
+/** Normalize a wire sort (single rule or list) into rules. */
+export function normalizeSort(sort: unknown): SortRule[] {
+  const list = Array.isArray(sort) ? sort : sort ? [sort] : [];
+  return (list as SortRule[]).filter(
+    (rule) => rule && typeof rule === "object" && typeof rule.field === "string",
+  );
+}
+
+/** Resolve a grammar field name to its physical column (`author` → `author_id` for refs). */
+export function columnForField(field: string, specs: ColumnSpec[]): string {
+  if (field === "id") {
+    return "id";
+  }
+  const spec = specs.find((s) => s.field === field || s.column === field);
+  return spec?.column ?? field;
+}
+
+/**
+ * Apply filter rules to a select builder (AND semantics, matching the in-memory evaluator).
+ *
+ * @param {DynamicSelect} qb
+ * @param {FilterRule[]} rules
+ * @param {ColumnSpec[]} specs - Column plan (field → column mapping, storage classes)
+ * @returns {DynamicSelect}
+ */
+export function applyFilter(
+  qb: DynamicSelect,
+  rules: FilterRule[],
+  specs: ColumnSpec[],
+): DynamicSelect {
+  let out = qb;
+  for (const rule of rules) {
+    const column = columnForField(rule.field, specs);
+    const spec = specs.find((s) => s.column === column) ?? null;
+    out = out.where((eb) => ruleExpression(eb, rule, column, spec));
+  }
+  return out;
+}
+
+/**
+ * Translate one filter rule into a boolean expression.
+ *
+ * @param {DynamicEb} eb
+ * @param {FilterRule} rule
+ * @param {string} column - Physical column name
+ * @param {ColumnSpec | null} spec - Column spec when known (storage-aware `contains`)
+ * @returns {BoolExpr}
+ */
+function ruleExpression(
+  eb: DynamicEb,
+  rule: FilterRule,
+  column: string,
+  spec: ColumnSpec | null,
+): BoolExpr {
+  const { op, value } = rule;
+  switch (op) {
+    case "==": {
+      return value === null || value === undefined
+        ? eb(column, "is", null)
+        : eb(column, "=", storageValue(spec, value));
+    }
+    case "!=": {
+      // NULL never equals the probe in the in-memory grammar, so NULL rows match `!=`.
+      return value === null || value === undefined
+        ? eb(column, "is not", null)
+        : eb.or([eb(column, "!=", storageValue(spec, value)), eb(column, "is", null)]);
+    }
+    case "empty": {
+      return eb.or([eb(column, "is", null), eb(column, "=", ""), eb(column, "=", "[]")]);
+    }
+    case "not empty": {
+      return eb.and([eb(column, "is not", null), eb(column, "!=", ""), eb(column, "!=", "[]")]);
+    }
+    case "contains": {
+      return eb(column, "like", containsPattern(spec, value));
+    }
+    case "not contains": {
+      return eb.or([eb(column, "not like", containsPattern(spec, value)), eb(column, "is", null)]);
+    }
+    case ">":
+    case "<":
+    case ">=":
+    case "<=": {
+      return eb(column, op, Number(value));
+    }
+    default: {
+      // Unknown ops match everything, like the in-memory evaluator.
+      return eb.lit(true as SqlBool);
+    }
+  }
+}
+
+/** LIKE pattern for `contains`: JSON columns match the JSON-encoded element. */
+function containsPattern(spec: ColumnSpec | null, value: unknown): string {
+  if (spec?.storage === "json") {
+    const encoded = JSON.stringify(value);
+    return `%${escapeLike(encoded)}%`;
+  }
+  return `%${escapeLike(String(value ?? ""))}%`;
+}
+
+/** Escape LIKE wildcards in a literal probe. */
+function escapeLike(text: string): string {
+  return text.replaceAll("%", String.raw`\%`).replaceAll("_", String.raw`\_`);
+}
+
+/** Coerce a filter probe value to the column's storage representation. */
+function storageValue(spec: ColumnSpec | null, value: unknown): string | number {
+  if (spec?.storage === "boolean") {
+    const truthy = value === true || value === "true" || value === 1 || value === "1";
+    return truthy ? 1 : 0;
+  }
+  if (spec?.storage === "json") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  return String(value);
+}
+
+/**
+ * Apply sort rules to a select builder.
+ *
+ * @param {DynamicSelect} qb
+ * @param {SortRule[]} rules
+ * @param {ColumnSpec[]} specs
+ * @returns {DynamicSelect}
+ */
+export function applySort(
+  qb: DynamicSelect,
+  rules: SortRule[],
+  specs: ColumnSpec[],
+): DynamicSelect {
+  let out = qb;
+  for (const rule of rules) {
+    const column = columnForField(rule.field, specs);
+    out = out.orderBy(column, rule.order === "desc" ? "desc" : "asc");
+  }
+  return out;
+}

package/src/sqlite.ts

@@ -0,0 +1,51 @@
+/**
+ * Sqlite provider — file-backed SQLite over bun:sqlite.
+ *
+ * The dev-server default and the `local: "sqlite"` stand-in target: connections resolve to
+ * `<root>/.jx/data/<name>.sqlite` (or the connection's `file` path) under the project root the host
+ * publishes as `env.JX_PROJECT_ROOT`. Node/Bun hosts only — deployed Cloudflare sites use D1 or
+ * Supabase.
+ */
+
+import { createBunSqliteDialect } from "./dialects/bun-sqlite.ts";
+import { deployWithDialect, testWithDialect } from "./provider-utils.ts";
+import type { Dialect } from "kysely";
+import type { ConnectorProvider } from "./provider-utils.ts";
+import type { ConnectionDef } from "./types.ts";
+
+/** Resolve the SQLite file path for a connection. */
+export function sqliteFilePath(connection: ConnectionDef, env: Record<string, unknown>): string {
+  const root = typeof env["JX_PROJECT_ROOT"] === "string" ? env["JX_PROJECT_ROOT"] : ".";
+  const name = connection.$name ?? "default";
+  const file = connection.file ?? `./.jx/data/${name}.sqlite`;
+  if (file === ":memory:" || file.startsWith("/")) {
+    return file;
+  }
+  return `${root.replace(/\/$/, "")}/${file.replace(/^\.\//, "")}`;
+}
+
+/** Build the bun:sqlite dialect for a connection. */
+function sqliteDialect(connection: ConnectionDef, env: Record<string, unknown>): Dialect {
+  return createBunSqliteDialect({ url: sqliteFilePath(connection, env) });
+}
+
+export const Sqlite = {
+  bindings: () => ({}),
+  deploySchema: async (
+    tables: Parameters<ConnectorProvider["deploySchema"]>[0],
+    connection: ConnectionDef,
+    options: { env: Record<string, unknown>; dryRun?: boolean },
+  ) => {
+    const dialect = sqliteDialect(connection, options.env);
+    return deployWithDialect(dialect, "sqlite", tables, { dryRun: options.dryRun ?? false });
+  },
+  dialect: sqliteDialect,
+  kind: "sqlite",
+  testConnection: async (connection: ConnectionDef, env: Record<string, unknown>) => {
+    try {
+      return await testWithDialect(sqliteDialect(connection, env));
+    } catch (error) {
+      return { error: error instanceof Error ? error.message : String(error), ok: false };
+    }
+  },
+} satisfies ConnectorProvider;

package/src/supabase.ts

@@ -0,0 +1,81 @@
+/**
+ * Supabase provider — postgres connections over postgres-js.
+ *
+ * The connection URL is never committed: `urlEnv` names the env var carrying it (.dev.vars locally,
+ * a platform secret in production). From Workers, a Hyperdrive binding (named by `binding`,
+ * provisioned from `hyperdriveId`) takes precedence — its `connectionString` fronts the database
+ * with connection pooling. postgres-js and the kysely-postgres-js dialect load lazily so hosts that
+ * never touch a postgres connection never import them.
+ */
+
+import { deployWithDialect, testWithDialect } from "./provider-utils.ts";
+import type { Dialect } from "kysely";
+import type { ConnectorProvider } from "./provider-utils.ts";
+import type { ConnectionDef } from "./types.ts";
+
+/**
+ * Resolve the postgres URL for a connection: Hyperdrive binding first, then `urlEnv`.
+ *
+ * @param {ConnectionDef} connection
+ * @param {Record<string, unknown>} env
+ * @returns {string}
+ */
+export function resolvePostgresUrl(
+  connection: ConnectionDef,
+  env: Record<string, unknown>,
+): string {
+  const { binding, urlEnv, $name = "connection" } = connection;
+  const bound = binding ? (env[binding] as { connectionString?: string } | undefined) : undefined;
+  if (bound && typeof bound.connectionString === "string") {
+    return bound.connectionString;
+  }
+  const url = urlEnv ? env[urlEnv] : undefined;
+  if (typeof url === "string" && url !== "") {
+    return url;
+  }
+  throw new Error(
+    `Supabase connection "${$name}" is unreachable: no "${binding ?? "<binding>"}" Hyperdrive ` +
+      `binding on env and ${urlEnv ? `env.${urlEnv} is unset` : `no "urlEnv" is configured`}`,
+  );
+}
+
+/** Build the postgres-js dialect for a URL (lazy imports keep non-postgres hosts lean). */
+async function postgresDialect(url: string): Promise<Dialect> {
+  const { default: postgres } = await import("postgres");
+  const { PostgresJSDialect } = await import("kysely-postgres-js");
+  // Prepare: false — Supabase's transaction-mode pooler does not support prepared statements.
+  return new PostgresJSDialect({ postgres: postgres(url, { prepare: false }) });
+}
+
+export const Supabase = {
+  bindings: (connection: ConnectionDef) =>
+    connection.hyperdriveId
+      ? {
+          hyperdrive: [
+            {
+              binding: connection.binding ?? "HYPERDRIVE",
+              id: connection.hyperdriveId,
+            },
+          ],
+        }
+      : {},
+  deploySchema: async (
+    tables: Parameters<ConnectorProvider["deploySchema"]>[0],
+    connection: ConnectionDef,
+    options: { env: Record<string, unknown>; dryRun?: boolean },
+  ) => {
+    const dialect = await postgresDialect(resolvePostgresUrl(connection, options.env));
+    return deployWithDialect(dialect, "postgres", tables, { dryRun: options.dryRun ?? false });
+  },
+  dialect: (connection: ConnectionDef, env: Record<string, unknown>) =>
+    postgresDialect(resolvePostgresUrl(connection, env)),
+  kind: "postgres",
+  testConnection: async (connection: ConnectionDef, env: Record<string, unknown>) => {
+    try {
+      const dialect = await postgresDialect(resolvePostgresUrl(connection, env));
+      return await testWithDialect(dialect);
+    } catch (error) {
+      return { error: error instanceof Error ? error.message : String(error), ok: false };
+    }
+  },
+} satisfies ConnectorProvider;