@xata.io/drizzle 0.0.0-alpha.vbb2f12358f020e051a1c8f430605b67f373c11d8 → 0.0.0-alpha.vbb31a357af5efed4080542c795c34cb2145a906c

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 {
@@ -78,10 +78,9 @@ function getDrizzleClient(type: string, branch: string) {
 
 describe.concurrent.each([{ type: 'pg' }, { type: 'http' }])('Drizzle $type', ({ type }) => {
   beforeAll(async () => {
-    await api.database.createDatabase({
-      workspace,
-      database,
-      data: { region, branchName: 'main' },
+    await api.databases.createDatabase({
+      pathParams: { workspaceId: workspace, dbName: database },
+      body: { region, branchName: 'main' },
       headers: { 'X-Features': 'feat-pgroll-migrations=1' }
     });
 
@@ -155,12 +154,15 @@ describe.concurrent.each([{ type: 'pg' }, { type: 'http' }])('Drizzle $type', ({
   });
 
   afterAll(async () => {
-    await api.database.deleteDatabase({ workspace, database });
+    await api.databases.deleteDatabase({ pathParams: { workspaceId: workspace, dbName: database } });
   });
 
   beforeEach(async (ctx) => {
     ctx.branch = `test-${Math.random().toString(36).substring(7)}`;
-    await api.branches.createBranch({ workspace, database, region, branch: ctx.branch, from: 'main' });
+    await api.branch.createBranch({
+      pathParams: { workspace, region, dbBranchName: `${database}:${ctx.branch}` },
+      body: { from: 'main' }
+    });
 
     const { db, client } = getDrizzleClient(type, ctx.branch);
     await client?.connect();
@@ -171,7 +173,7 @@ describe.concurrent.each([{ type: 'pg' }, { type: 'http' }])('Drizzle $type', ({
 
   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: `${database}:${ctx.branch}` } });
   });
 
   /*
@@ -891,133 +893,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([
@@ -6412,7 +6287,7 @@ describe.concurrent.each([{ type: 'pg' }, { type: 'http' }])('Drizzle $type', ({
 async function waitForReplication(): Promise<void> {
   try {
     await new Promise((resolve) => setTimeout(resolve, 2000));
-    await api.branches.getBranchList({ workspace, database, region });
+    await api.branch.getBranchList({ pathParams: { workspace, dbName: database, region } });
   } catch (error) {
     console.log(`Replication not ready yet, retrying...`);
     return await waitForReplication();