feat: remove data api sdk base

.changeset/fast-dragons-punch.md

@@ -0,0 +1,5 @@
+---
+"@xata.io/client": patch
+---
+
+Remove ifVersion

.changeset/light-cycles-repair.md

@@ -0,0 +1,5 @@
+---
+'@xata.io/client': major
+---
+
+Make XataApiClient to use ES Proxies

.changeset/sixty-points-tell.md

@@ -1,5 +1,5 @@
 ---
-"@xata.io/cli": patch
+'@xata.io/cli': patch
 ---
 
 Do not prompt for update on pre release

cli/src/base.ts

@@ -28,7 +28,7 @@ import { reportBugURL } from './utils.js';
 export class XataClient extends buildClient({
   api: new XataApiPlugin(),
   import: new XataImportPlugin()
-}) {}
+})<any> {}
 
 export type APIKeyLocation = 'shell' | 'dotenv' | 'profile' | 'new';
 
@@ -212,15 +212,18 @@ export abstract class BaseCommand<T extends typeof Command> extends Command {
     const databaseURL = flags.db ?? `${getHostUrl(host, 'workspaces')}/db/{database}`;
     const branch = flags.branch ?? this.getCurrentBranchName();
 
-    this.#xataClient = new XataClient({
-      databaseURL,
-      branch,
-      apiKey,
-      fetch,
-      host,
-      clientName: 'cli',
-      xataAgentExtra: { cliCommandId: this.id ?? 'unknown' }
-    });
+    this.#xataClient = new XataClient(
+      {
+        databaseURL,
+        branch,
+        apiKey,
+        fetch,
+        host,
+        clientName: 'cli',
+        xataAgentExtra: { cliCommandId: this.id ?? 'unknown' }
+      },
+      { tables: [] }
+    );
 
     return this.#xataClient;
   }

cli/src/commands/import/csv.ts

@@ -156,30 +156,24 @@ export default class ImportCSV extends BaseCommand<typeof ImportCSV> {
         if (!parseResults.success) {
           throw new Error('Failed to parse CSV file');
         }
-        const batchRows = () => {
-          if (this.#pgrollEnabled) {
-            const res = parseResults.data.map(({ data }) => {
-              const formattedRow: { [k: string]: any } = {};
-              const keys = Object.keys(data);
-              for (const key of keys) {
-                if (INTERNAL_COLUMNS_PGROLL.includes(key) && key !== 'xata_id') continue;
-                formattedRow[key] = data[key];
-              }
-              return formattedRow;
-            });
-            return res;
-          } else {
-            return parseResults.data.map(({ data }) => data);
+        const batchRows = parseResults.data.map(({ data }) => {
+          const formattedRow: { [k: string]: any } = {};
+          const keys = Object.keys(data);
+          for (const key of keys) {
+            if (INTERNAL_COLUMNS_PGROLL.includes(key) && key !== 'xata_id') continue;
+            formattedRow[key] = data[key];
           }
-        };
+          return formattedRow;
+        });
+
         const importResult = await xata.import.importBatch(
           { workspace, region, database, branch },
           {
-            columns: this.#pgrollEnabled
-              ? parseResults.columns.filter(({ name }) => name === 'xata_id' || !INTERNAL_COLUMNS_PGROLL.includes(name))
-              : parseResults.columns,
+            columns: parseResults.columns.filter(
+              ({ name }) => name === 'xata_id' || !INTERNAL_COLUMNS_PGROLL.includes(name)
+            ),
             table,
-            batchRows: batchRows()
+            batchRows
           }
         );
         await xata.import.importFiles(

cli/src/commands/init/index.test.ts

@@ -164,11 +164,11 @@ describe('xata init', () => {
         XataRecord,
       } from "@xata.io/client";
 
-      const tables = [
-        { name: "table1", columns: [{ name: "a", type: "string" }] },
-      ] as const;
+      const schema = {
+        tables: [{ name: "table1", columns: [{ name: "a", type: "string" }] }],
+      } as const;
 
-      export type SchemaTables = typeof tables;
+      export type SchemaTables = typeof schema.tables;
       export type InferredTypes = SchemaInference<SchemaTables>;
 
       export type Table1 = InferredTypes["table1"];
@@ -180,7 +180,7 @@ describe('xata init', () => {
 
       const DatabaseClient = buildClient();
 
-      export class XataClient extends DatabaseClient<DatabaseSchema> {
+      export class XataClient extends DatabaseClient<typeof schema> {
         constructor(options?: BaseClientOptions) {
           super(
             {
@@ -193,7 +193,7 @@ describe('xata init', () => {
                 "main",
               ...options,
             },
-            tables
+            schema
           );
         }
       }
@@ -247,11 +247,11 @@ describe('xata init', () => {
         XataRecord,
       } from "@xata.io/client";
 
-      const tables = [
-        { name: "table1", columns: [{ name: "a", type: "string" }] },
-      ] as const;
+      const schema = {
+        tables: [{ name: "table1", columns: [{ name: "a", type: "string" }] }],
+      } as const;
 
-      export type SchemaTables = typeof tables;
+      export type SchemaTables = typeof schema.tables;
       export type InferredTypes = SchemaInference<SchemaTables>;
 
       export type Table1 = InferredTypes["table1"];
@@ -263,7 +263,7 @@ describe('xata init', () => {
 
       const DatabaseClient = buildClient();
 
-      export class XataClient extends DatabaseClient<DatabaseSchema> {
+      export class XataClient extends DatabaseClient<typeof schema> {
         constructor(options?: BaseClientOptions) {
           super(
             {
@@ -276,7 +276,7 @@ describe('xata init', () => {
                 "main",
               ...options,
             },
-            tables
+            schema
           );
         }
       }
@@ -325,11 +325,11 @@ describe('xata init', () => {
         XataRecord,
       } from "npm:@xata.io/client@latest";
 
-      const tables = [
-        { name: "table1", columns: [{ name: "a", type: "string" }] },
-      ] as const;
+      const schema = {
+        tables: [{ name: "table1", columns: [{ name: "a", type: "string" }] }],
+      } as const;
 
-      export type SchemaTables = typeof tables;
+      export type SchemaTables = typeof schema.tables;
       export type InferredTypes = SchemaInference<SchemaTables>;
 
       export type Table1 = InferredTypes["table1"];
@@ -341,7 +341,7 @@ describe('xata init', () => {
 
       const DatabaseClient = buildClient();
 
-      export class XataClient extends DatabaseClient<DatabaseSchema> {
+      export class XataClient extends DatabaseClient<typeof schema> {
         constructor(options?: BaseClientOptions) {
           super(
             {
@@ -354,7 +354,7 @@ describe('xata init', () => {
                 "main",
               ...options,
             },
-            tables
+            schema
           );
         }
       }
@@ -404,11 +404,11 @@ describe('xata init', () => {
         XataRecord,
       } from "@xata.io/client";
 
-      const tables = [
-        { name: "table1", columns: [{ name: "a", type: "string" }] },
-      ] as const;
+      const schema = {
+        tables: [{ name: "table1", columns: [{ name: "a", type: "string" }] }],
+      } as const;
 
-      export type SchemaTables = typeof tables;
+      export type SchemaTables = typeof schema.tables;
       export type InferredTypes = SchemaInference<SchemaTables>;
 
       export type Table1 = InferredTypes["table1"];
@@ -420,7 +420,7 @@ describe('xata init', () => {
 
       const DatabaseClient = buildClient();
 
-      export class XataClient extends DatabaseClient<DatabaseSchema> {
+      export class XataClient extends DatabaseClient<typeof schema> {
         constructor(options?: BaseClientOptions) {
           super(
             {
@@ -433,7 +433,7 @@ describe('xata init', () => {
                 "main",
               ...options,
             },
-            tables
+            schema
           );
         }
       }

cli/src/commands/init/index.ts

@@ -201,8 +201,12 @@ export default class Init extends BaseCommand<typeof Init> {
     this.log();
 
     if (this.projectConfig?.codegen?.output) {
-      const hasTables = this.branchDetails.schema?.tables && this.branchDetails.schema?.tables.length > 0;
-      const hasColumns = this.branchDetails.schema?.tables.some((t) => t.columns.length > 0);
+      const { schema: currentSchema } = await (
+        await this.getXataClient()
+      ).api.branch.getBranchDetails({ pathParams: { workspace, region, dbBranchName: `${database}:${branch}` } });
+
+      const hasTables = currentSchema?.tables && currentSchema?.tables.length > 0;
+      const hasColumns = currentSchema?.tables.some((t) => t.columns.length > 0);
       const isSchemaSetup = hasTables && hasColumns;
       if (shouldInstallPackage && !canInstallPackage) {
         this.warn(

cli/src/commands/schema/edit.test.ts

@@ -1,6 +1,6 @@
 import { PgRollMigration } from '@xata.io/pgroll';
 import { beforeEach, describe, expect, test } from 'vitest';
-import EditSchemaNew, {
+import EditSchema, {
   AddColumnPayload,
   AddTablePayload,
   ColumnAdditions,
@@ -108,7 +108,7 @@ const createEdit = (column: ColumnData) => {
 const runTest = (name: string, setup: () => void, expectation: any) => {
   test(name, () => {
     setup();
-    editCommand.currentMigration.operations = editsToMigrations(editCommand as EditSchemaNew);
+    editCommand.currentMigration.operations = editsToMigrations(editCommand as EditSchema);
     expect(editCommand.currentMigration.operations).toEqual(expectation);
   });
 };

cli/src/migrations/pgroll.ts

@@ -346,12 +346,7 @@ export async function waitForMigrationToFinish(
   jobId: string
 ): Promise<void> {
   const { status, error } = await api.migrations.getMigrationJobStatus({
-    pathParams: {
-      workspace: workspace,
-      region: region,
-      dbBranchName: `${database}:${branch}`,
-      jobId
-    }
+    pathParams: { workspace, region, dbBranchName: `${database}:${branch}`, jobId }
   });
   if (status === 'failed') {
     throw new Error(`Migration failed, ${error}`);

packages/client/package.json

@@ -33,5 +33,10 @@
   "bugs": {
     "url": "https://github.com/xataio/client-ts/issues"
   },
-  "homepage": "https://xata.io/docs/sdk/getting-started"
+  "homepage": "https://xata.io/docs/sdk/getting-started",
+  "dependencies": {
+    "kysely": "^0.27.3",
+    "@xata.io/sql": "workspace:*",
+    "@xata.io/kysely": "workspace:*"
+  }
 }

packages/client/src/client.ts

@@ -1,11 +1,10 @@
-import { ApiExtraProps, HostProvider, Schemas } from './api';
+import { ApiExtraProps, HostProvider } from './api';
 import { FilesPlugin, FilesPluginResult } from './files';
 import { XataPlugin, XataPluginOptions } from './plugins';
-import { BaseSchema, SchemaPlugin, SchemaPluginResult, XataRecord } from './schema';
+import { DatabaseSchema, SchemaInference, SchemaPlugin, SchemaPluginResult } from './schema';
 import { defaultTrace, TraceFunction } from './schema/tracing';
 import { SearchPlugin, SearchPluginResult } from './search';
 import { SQLPlugin, SQLPluginResult } from './sql';
-import { TransactionPlugin, TransactionPluginResult } from './transaction';
 import { FetchImpl, getFetchImplementation } from './util/fetch';
 import { AllRequired, StringKeys } from './util/types';
 import { generateUUID } from './util/uuid';
@@ -33,35 +32,32 @@ export const buildClient = <Plugins extends Record<string, XataPlugin> = {}>(plu
   class {
     #options: SafeOptions;
 
-    schema: Schemas.Schema;
+    schema: DatabaseSchema;
     db: SchemaPluginResult<any>;
     search: SearchPluginResult<any>;
-    transactions: TransactionPluginResult<any>;
     sql: SQLPluginResult;
     files: FilesPluginResult<any>;
 
-    constructor(options: BaseClientOptions = {}, tables: Schemas.Table[]) {
+    constructor(options: BaseClientOptions = {}, schema: DatabaseSchema) {
       const safeOptions = this.#parseOptions(options);
       this.#options = safeOptions;
 
       const pluginOptions: XataPluginOptions = {
         ...this.#getFetchProps(safeOptions),
         host: safeOptions.host,
-        tables,
+        schema,
         branch: safeOptions.branch
       };
 
       const db = new SchemaPlugin().build(pluginOptions);
       const search = new SearchPlugin(db).build(pluginOptions);
-      const transactions = new TransactionPlugin().build(pluginOptions);
       const sql = new SQLPlugin().build(pluginOptions);
       const files = new FilesPlugin().build(pluginOptions);
 
       // We assign the namespaces after creating in case the user overrides the db plugin
-      this.schema = { tables };
+      this.schema = schema;
       this.db = db;
       this.search = search;
-      this.transactions = transactions;
       this.sql = sql;
       this.files = files;
 
@@ -155,16 +151,13 @@ export const buildClient = <Plugins extends Record<string, XataPlugin> = {}>(plu
   } as unknown as ClientConstructor<Plugins>;
 
 export interface ClientConstructor<Plugins extends Record<string, XataPlugin>> {
-  new <Schemas extends Record<string, XataRecord> = {}>(
-    options?: Partial<BaseClientOptions>,
-    schemaTables?: readonly BaseSchema[]
-  ): Omit<
+  new <Schema extends DatabaseSchema>(options: BaseClientOptions, schema: Schema): Omit<
     {
-      db: Awaited<ReturnType<SchemaPlugin<Schemas>['build']>>;
-      search: Awaited<ReturnType<SearchPlugin<Schemas>['build']>>;
-      transactions: Awaited<ReturnType<TransactionPlugin<Schemas>['build']>>;
+      db: Awaited<ReturnType<SchemaPlugin<Schema>['build']>>;
+      search: Awaited<ReturnType<SearchPlugin<Schema>['build']>>;
       sql: Awaited<ReturnType<SQLPlugin['build']>>;
-      files: Awaited<ReturnType<FilesPlugin<Schemas>['build']>>;
+      files: Awaited<ReturnType<FilesPlugin<SchemaInference<Schema['tables']>>['build']>>;
+      schema: Schema;
     },
     keyof Plugins
   > & {
@@ -177,4 +170,4 @@ export interface ClientConstructor<Plugins extends Record<string, XataPlugin>> {
   };
 }
 
-export class BaseClient extends buildClient()<Record<string, any>> {}
+export class BaseClient extends buildClient()<DatabaseSchema> {}

packages/client/src/files/index.ts

@@ -2,7 +2,7 @@ import { deleteFileItem, getFileItem, putFileItem } from '../api';
 import { FileResponse } from '../api/dataPlaneSchemas';
 import { XataPlugin, XataPluginOptions } from '../plugins';
 import { ColumnsByValue, XataArrayFile, XataFile } from '../schema';
-import { BaseData, XataRecord } from '../schema/record';
+import { BaseData } from '../schema/record';
 import { isBlob } from '../util/lang';
 import { GetArrayInnerType, StringKeys, Values } from '../util/types';
 
@@ -48,7 +48,7 @@ export type DownloadDestination<Schemas extends Record<string, BaseData>, Tables
       };
 }>;
 
-export class FilesPlugin<Schemas extends Record<string, XataRecord>> extends XataPlugin {
+export class FilesPlugin<Schemas extends Record<string, any>> extends XataPlugin {
   build(pluginOptions: XataPluginOptions): FilesPluginResult<Schemas> {
     return {
       download: async (location: Record<string, string | undefined>) => {