@xata.io/drizzle 0.0.0-alpha.vdd8d5bd666d1807ed5f272e3ccba99605495f3aa → 0.0.0-alpha.vddec8625ad4dd2e901ec75eef5769e604f210360

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xata.io/drizzle",
-  "version": "0.0.0-alpha.vdd8d5bd666d1807ed5f272e3ccba99605495f3aa",
+  "version": "0.0.0-alpha.vddec8625ad4dd2e901ec75eef5769e604f210360",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -10,6 +10,11 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
+    },
+    "./pg": {
+      "import": "./dist/pg.mjs",
+      "require": "./dist/pg.cjs",
+      "types": "./dist/pg.d.ts"
     }
   },
   "author": "",
@@ -18,15 +23,15 @@
     "url": "https://github.com/xataio/client-ts/issues"
   },
   "dependencies": {
-    "pg": "^8.11.3",
-    "@xata.io/client": "0.0.0-alpha.vdd8d5bd666d1807ed5f272e3ccba99605495f3aa"
+    "@xata.io/client": "0.0.0-alpha.vddec8625ad4dd2e901ec75eef5769e604f210360"
   },
   "devDependencies": {
-    "@types/pg": "^8.11.0",
-    "drizzle-orm": "^0.29.3"
+    "@types/pg": "^8.11.10",
+    "drizzle-orm": "^0.33.0",
+    "pg": "^8.13.0"
   },
   "peerDependencies": {
-    "drizzle-orm": "^0.28.5"
+    "drizzle-orm": "*"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",

package/test/drizzle.test.ts

@@ -1,6 +1,6 @@
 import { BaseClient, HostProvider, parseProviderString, XataApiClient } from '@xata.io/client';
 import 'dotenv/config';
-import { desc, DrizzleError, eq, gt, gte, or, placeholder, sql, TransactionRollbackError } from 'drizzle-orm';
+import { desc, DrizzleError, eq, gt, gte, or, placeholder, sql } from 'drizzle-orm';
 import { Client } from 'pg';
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expectTypeOf, test } from 'vitest';
 import { drizzle as drizzlePg, type XataDatabase } from '../src/pg';
@@ -9,7 +9,7 @@ import * as schema from './schema';
 
 const { usersTable, postsTable, commentsTable, usersToGroupsTable, groupsTable } = schema;
 
-const ENABLE_LOGGING = true;
+const ENABLE_LOGGING = false;
 
 declare module 'vitest' {
   export interface TestContext {
@@ -51,25 +51,48 @@ function getDomain(host: HostProvider) {
   }
 }
 
-beforeAll(async () => {
-  await api.database.createDatabase({
-    workspace,
-    database,
-    data: { region, branchName: 'main' },
-    headers: { 'X-Features': 'feat-pgroll-migrations=1' }
-  });
+function getDrizzleClient(type: string, database: string, branch: string) {
+  if (type === 'http') {
+    const xata = new BaseClient({
+      apiKey,
+      host,
+      clientName: 'sdk-tests',
+      databaseURL: `https://${workspace}.${region}.${getDomain(host)}/db/${database}`,
+      branch
+    });
 
-  await waitForReplication();
+    return { db: drizzleHttp(xata, { schema, logger: ENABLE_LOGGING }) };
+  } else if (type === 'pg') {
+    const client = new Client({
+      connectionString: `postgresql://${workspace}:${apiKey}@${region}.sql.${getDomain(
+        host
+      )}:5432/${database}:${branch}`,
+      ssl: true
+    });
 
-  const client = new Client({
-    connectionString: `postgresql://${workspace}:${apiKey}@${region}.sql.${getDomain(host)}:5432/${database}:main`
-  });
+    return { db: drizzlePg(client, { schema, logger: ENABLE_LOGGING }), client };
+  } else {
+    throw new Error(`Unknown type: ${type}`);
+  }
+}
 
-  await client.connect();
-  const db = drizzlePg(client, { schema, logger: ENABLE_LOGGING });
+describe.concurrent.each([{ type: 'pg' }, { type: 'http' }])('Drizzle $type', ({ type }) => {
+  const dbName = `${database}-${type}`;
 
-  await db.execute(
-    sql`
+  beforeAll(async () => {
+    await api.databases.createDatabase({
+      pathParams: { workspaceId: workspace, dbName },
+      body: { region, branchName: 'main', postgresEnabled: true }
+    });
+
+    await waitForReplication(dbName);
+
+    // For now, run the migrations via wire protocol
+    const { client, db } = getDrizzleClient('pg', dbName, 'main');
+    await client?.connect();
+
+    await db.execute(
+      sql`
 			CREATE TABLE "users" (
 				"id" serial PRIMARY KEY NOT NULL,
 				"name" text NOT NULL,
@@ -77,27 +100,27 @@ beforeAll(async () => {
 				"invited_by" int REFERENCES "users"("id")
 			);
 		`
-  );
-  await db.execute(
-    sql`
+    );
+    await db.execute(
+      sql`
 			CREATE TABLE IF NOT EXISTS "groups" (
 				"id" serial PRIMARY KEY NOT NULL,
 				"name" text NOT NULL,
 				"description" text
 			);
 		`
-  );
-  await db.execute(
-    sql`
+    );
+    await db.execute(
+      sql`
 			CREATE TABLE IF NOT EXISTS "users_to_groups" (
 				"id" serial PRIMARY KEY NOT NULL,
 				"user_id" int REFERENCES "users"("id"),
 				"group_id" int REFERENCES "groups"("id")
 			);
 		`
-  );
-  await db.execute(
-    sql`
+    );
+    await db.execute(
+      sql`
 			CREATE TABLE IF NOT EXISTS "posts" (
 				"id" serial PRIMARY KEY NOT NULL,
 				"content" text NOT NULL,
@@ -105,9 +128,9 @@ beforeAll(async () => {
 				"created_at" timestamp with time zone DEFAULT now() NOT NULL
 			);
 		`
-  );
-  await db.execute(
-    sql`
+    );
+    await db.execute(
+      sql`
 			CREATE TABLE IF NOT EXISTS "comments" (
 				"id" serial PRIMARY KEY NOT NULL,
 				"content" text NOT NULL,
@@ -116,9 +139,9 @@ beforeAll(async () => {
 				"created_at" timestamp with time zone DEFAULT now() NOT NULL
 			);
 		`
-  );
-  await db.execute(
-    sql`
+    );
+    await db.execute(
+      sql`
 			CREATE TABLE IF NOT EXISTS "comment_likes" (
 				"id" serial PRIMARY KEY NOT NULL,
 				"creator" int REFERENCES "users"("id"),
@@ -126,47 +149,32 @@ beforeAll(async () => {
 				"created_at" timestamp with time zone DEFAULT now() NOT NULL
 			);
 		`
-  );
+    );
 
-  await client.end();
-});
+    await client?.end();
+  });
 
-afterAll(async () => {
-  await api.database.deleteDatabase({ workspace, database });
-});
+  afterAll(async () => {
+    await api.databases.deleteDatabase({ pathParams: { workspaceId: workspace, dbName } });
+  });
 
-describe.concurrent.each([{ type: 'pg' } /**{ type: 'http' }**/])('Drizzle $type', ({ type }) => {
   beforeEach(async (ctx) => {
     ctx.branch = `test-${Math.random().toString(36).substring(7)}`;
-    await api.branches.createBranch({ workspace, database, region, branch: ctx.branch, from: 'main' });
-
-    if (type === 'http') {
-      const xata = new BaseClient({
-        apiKey,
-        host,
-        clientName: 'sdk-tests',
-        databaseURL: `https://${workspace}.${region}.${getDomain(host)}/db/${database}`,
-        branch: ctx.branch
-      });
-
-      ctx.db = drizzleHttp(xata, { schema, logger: ENABLE_LOGGING });
-    } else if (type === 'pg') {
-      ctx.client = new Client({
-        connectionString: `postgresql://${workspace}:${apiKey}@${region}.sql.${getDomain(host)}:5432/${database}:${
-          ctx.branch
-        }`
-      });
-
-      await ctx.client.connect();
-      ctx.db = drizzlePg(ctx.client, { schema, logger: ENABLE_LOGGING });
-    } else {
-      throw new Error(`Unknown type: ${type}`);
-    }
+    await api.branch.createBranch({
+      pathParams: { workspace, region, dbBranchName: `${dbName}:${ctx.branch}` },
+      body: { from: 'main' }
+    });
+
+    const { db, client } = getDrizzleClient(type, dbName, ctx.branch);
+    await client?.connect();
+
+    ctx.db = db;
+    ctx.client = client;
   });
 
   afterEach(async (ctx) => {
     await ctx.client?.end();
-    await api.branches.deleteBranch({ workspace, database, region, branch: ctx.branch });
+    await api.branch.deleteBranch({ pathParams: { workspace, region, dbBranchName: `${dbName}:${ctx.branch}` } });
   });
 
   /*
@@ -886,133 +894,6 @@ describe.concurrent.each([{ type: 'pg' } /**{ type: 'http' }**/])('Drizzle $type
     });
   });
 
-  test('[Find Many] Get users with posts in transaction', async (ctx) => {
-    let usersWithPosts: {
-      id: number;
-      name: string;
-      verified: boolean;
-      invitedBy: number | null;
-      posts: {
-        id: number;
-        content: string;
-        ownerId: number | null;
-        createdAt: Date;
-      }[];
-    }[] = [];
-
-    await ctx.db.transaction(async (tx) => {
-      await tx.insert(usersTable).values([
-        { id: 1, name: 'Dan' },
-        { id: 2, name: 'Andrew' },
-        { id: 3, name: 'Alex' }
-      ]);
-
-      await tx.insert(postsTable).values([
-        { ownerId: 1, content: 'Post1' },
-        { ownerId: 1, content: 'Post1.1' },
-        { ownerId: 2, content: 'Post2' },
-        { ownerId: 3, content: 'Post3' }
-      ]);
-
-      usersWithPosts = await tx.query.usersTable.findMany({
-        where: ({ id }, { eq }) => eq(id, 1),
-        with: {
-          posts: {
-            where: ({ id }, { eq }) => eq(id, 1)
-          }
-        }
-      });
-    });
-
-    expectTypeOf(usersWithPosts).toEqualTypeOf<
-      {
-        id: number;
-        name: string;
-        verified: boolean;
-        invitedBy: number | null;
-        posts: {
-          id: number;
-          content: string;
-          ownerId: number | null;
-          createdAt: Date;
-        }[];
-      }[]
-    >();
-
-    ctx.expect(usersWithPosts.length).eq(1);
-    ctx.expect(usersWithPosts[0]?.posts.length).eq(1);
-
-    ctx.expect(usersWithPosts[0]).toEqual({
-      id: 1,
-      name: 'Dan',
-      verified: false,
-      invitedBy: null,
-      posts: [{ id: 1, ownerId: 1, content: 'Post1', createdAt: usersWithPosts[0]?.posts[0]?.createdAt }]
-    });
-  });
-
-  test('[Find Many] Get users with posts in rollbacked transaction', async (ctx) => {
-    let usersWithPosts: {
-      id: number;
-      name: string;
-      verified: boolean;
-      invitedBy: number | null;
-      posts: {
-        id: number;
-        content: string;
-        ownerId: number | null;
-        createdAt: Date;
-      }[];
-    }[] = [];
-
-    await ctx
-      .expect(
-        ctx.db.transaction(async (tx) => {
-          await tx.insert(usersTable).values([
-            { id: 1, name: 'Dan' },
-            { id: 2, name: 'Andrew' },
-            { id: 3, name: 'Alex' }
-          ]);
-
-          await tx.insert(postsTable).values([
-            { ownerId: 1, content: 'Post1' },
-            { ownerId: 1, content: 'Post1.1' },
-            { ownerId: 2, content: 'Post2' },
-            { ownerId: 3, content: 'Post3' }
-          ]);
-
-          tx.rollback();
-
-          usersWithPosts = await tx.query.usersTable.findMany({
-            where: ({ id }, { eq }) => eq(id, 1),
-            with: {
-              posts: {
-                where: ({ id }, { eq }) => eq(id, 1)
-              }
-            }
-          });
-        })
-      )
-      .rejects.toThrowError(new TransactionRollbackError());
-
-    expectTypeOf(usersWithPosts).toEqualTypeOf<
-      {
-        id: number;
-        name: string;
-        verified: boolean;
-        invitedBy: number | null;
-        posts: {
-          id: number;
-          content: string;
-          ownerId: number | null;
-          createdAt: Date;
-        }[];
-      }[]
-    >();
-
-    ctx.expect(usersWithPosts.length).eq(0);
-  });
-
   // select only custom
   test('[Find Many] Get only custom fields', async (ctx) => {
     await ctx.db.insert(usersTable).values([
@@ -6404,12 +6285,12 @@ describe.concurrent.each([{ type: 'pg' } /**{ type: 'http' }**/])('Drizzle $type
   });
 });
 
-async function waitForReplication(): Promise<void> {
+async function waitForReplication(dbName: string): Promise<void> {
   try {
-    await api.branches.getBranchList({ workspace, database, region });
-  } catch (error) {
-    console.log(`Waiting for create database replication to finish...`);
     await new Promise((resolve) => setTimeout(resolve, 2000));
-    return await waitForReplication();
+    await api.branch.getBranchList({ pathParams: { workspace, dbName, region } });
+  } catch (error) {
+    console.log(`Replication not ready yet, retrying...`);
+    return await waitForReplication(dbName);
   }
 }