@xata.io/client 0.0.0-beta.9d62fb3 → 0.0.0-beta.bdce130

package/dist/api/client.d.ts

@@ -0,0 +1,90 @@
+import type * as Types from './components';
+import type { FetcherExtraProps, FetchImpl } from './fetcher';
+import { HostProvider } from './providers';
+import type * as Responses from './responses';
+import type * as Schemas from './schemas';
+export interface XataApiClientOptions {
+    fetch: FetchImpl;
+    apiKey: string;
+    host?: HostProvider;
+}
+export declare class XataApiClient {
+    private extraProps;
+    constructor(options: XataApiClientOptions);
+    get user(): UserApi;
+    get workspaces(): WorkspaceApi;
+    get databases(): DatabaseApi;
+    get branches(): BranchApi;
+    get tables(): TableApi;
+    get records(): RecordsApi;
+}
+declare class UserApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    getUser(): Promise<Schemas.UserWithID>;
+    updateUser(user: Schemas.User): Promise<Schemas.UserWithID>;
+    deleteUser(): Promise<void>;
+    getUserAPIKeys(): Promise<Types.GetUserAPIKeysResponse>;
+    createUserAPIKey(keyName: Schemas.APIKeyName): Promise<Types.CreateUserAPIKeyResponse>;
+    deleteUserAPIKey(keyName: Schemas.APIKeyName): Promise<void>;
+}
+declare class WorkspaceApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    createWorkspace(workspaceMeta: Schemas.WorkspaceMeta): Promise<Schemas.Workspace>;
+    getWorkspacesList(): Promise<Types.GetWorkspacesListResponse>;
+    getWorkspace(workspaceId: Schemas.WorkspaceID): Promise<Schemas.Workspace>;
+    updateWorkspace(workspaceId: Schemas.WorkspaceID, workspaceMeta: Schemas.WorkspaceMeta): Promise<Schemas.Workspace>;
+    deleteWorkspace(workspaceId: Schemas.WorkspaceID): Promise<void>;
+    getWorkspaceMembersList(workspaceId: Schemas.WorkspaceID): Promise<Schemas.WorkspaceMembers>;
+    updateWorkspaceMemberRole(workspaceId: Schemas.WorkspaceID, userId: Schemas.UserID, role: Schemas.Role): Promise<void>;
+    removeWorkspaceMember(workspaceId: Schemas.WorkspaceID, userId: Schemas.UserID): Promise<void>;
+    inviteWorkspaceMember(workspaceId: Schemas.WorkspaceID, email: string, role: Schemas.Role): Promise<Schemas.WorkspaceInvite>;
+    acceptWorkspaceMemberInvite(workspaceId: Schemas.WorkspaceID, inviteKey: Schemas.InviteKey): Promise<void>;
+}
+declare class DatabaseApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    getDatabaseList(workspace: Schemas.WorkspaceID): Promise<Schemas.ListDatabasesResponse>;
+    createDatabase(workspace: Schemas.WorkspaceID, dbName: Schemas.DBName, options?: Types.CreateDatabaseRequestBody): Promise<Types.CreateDatabaseResponse>;
+    deleteDatabase(workspace: Schemas.WorkspaceID, dbName: Schemas.DBName): Promise<void>;
+}
+declare class BranchApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    getBranchList(workspace: Schemas.WorkspaceID, dbName: Schemas.DBName): Promise<Schemas.ListBranchesResponse>;
+    getBranchDetails(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName): Promise<Schemas.DBBranch>;
+    createBranch(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, from?: string, options?: Types.CreateBranchRequestBody): Promise<void>;
+    deleteBranch(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName): Promise<void>;
+    updateBranchMetadata(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, metadata?: Schemas.BranchMetadata): Promise<void>;
+    getBranchMetadata(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName): Promise<Schemas.BranchMetadata>;
+    getBranchMigrationHistory(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, options?: Types.GetBranchMigrationHistoryRequestBody): Promise<Types.GetBranchMigrationHistoryResponse>;
+    executeBranchMigrationPlan(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, migrationPlan: Types.ExecuteBranchMigrationPlanRequestBody): Promise<void>;
+    getBranchMigrationPlan(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, schema: Schemas.Schema): Promise<Responses.BranchMigrationPlan>;
+    getBranchStats(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName): Promise<Types.GetBranchStatsResponse>;
+}
+declare class TableApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    createTable(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName): Promise<void>;
+    deleteTable(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName): Promise<void>;
+    updateTable(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, options: Types.UpdateTableRequestBody): Promise<void>;
+    getTableSchema(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName): Promise<Types.GetTableSchemaResponse>;
+    setTableSchema(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, options: Types.SetTableSchemaRequestBody): Promise<void>;
+    getTableColumns(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName): Promise<Types.GetTableColumnsResponse>;
+    addTableColumn(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, column: Schemas.Column): Promise<Responses.MigrationIdResponse>;
+    getColumn(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, columnName: Schemas.ColumnName): Promise<Schemas.Column>;
+    deleteColumn(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, columnName: Schemas.ColumnName): Promise<Responses.MigrationIdResponse>;
+    updateColumn(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, columnName: Schemas.ColumnName, options: Types.UpdateColumnRequestBody): Promise<Responses.MigrationIdResponse>;
+}
+declare class RecordsApi {
+    private extraProps;
+    constructor(extraProps: FetcherExtraProps);
+    insertRecord(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, record: Record<string, any>): Promise<Types.InsertRecordResponse>;
+    insertRecordWithID(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, recordId: Schemas.RecordID, record: Record<string, any>, options?: Types.InsertRecordWithIDQueryParams): Promise<Types.InsertRecordWithIDResponse>;
+    deleteRecord(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, recordId: Schemas.RecordID): Promise<void>;
+    getRecord(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, recordId: Schemas.RecordID, options?: Types.GetRecordRequestBody): Promise<Schemas.XataRecord>;
+    bulkInsertTableRecords(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, records: Record<string, any>[]): Promise<Types.BulkInsertTableRecordsResponse>;
+    queryTable(workspace: Schemas.WorkspaceID, database: Schemas.DBName, branch: Schemas.BranchName, tableName: Schemas.TableName, query: Types.QueryTableRequestBody): Promise<Responses.QueryResponse>;
+}
+export {};

package/dist/api/client.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XataApiClient = void 0;
+const components_1 = require("./components");
+const providers_1 = require("./providers");
+class XataApiClient {
+    constructor(options) {
+        var _a;
+        const fetchImpl = typeof fetch !== 'undefined' ? fetch : options.fetch;
+        if (!fetchImpl) {
+            /** @todo add a link after docs exist */
+            throw new Error(`The \`fetch\` option passed to the Xata client is resolving to a falsy value and may not be correctly imported.`);
+        }
+        const provider = (_a = options.host) !== null && _a !== void 0 ? _a : 'production';
+        this.extraProps = {
+            apiUrl: (0, providers_1.getHostUrl)(provider, 'main'),
+            workspacesApiUrl: (0, providers_1.getHostUrl)(provider, 'workspaces'),
+            fetchImpl,
+            apiKey: options.apiKey
+        };
+    }
+    get user() {
+        return new UserApi(this.extraProps);
+    }
+    get workspaces() {
+        return new WorkspaceApi(this.extraProps);
+    }
+    get databases() {
+        return new DatabaseApi(this.extraProps);
+    }
+    get branches() {
+        return new BranchApi(this.extraProps);
+    }
+    get tables() {
+        return new TableApi(this.extraProps);
+    }
+    get records() {
+        return new RecordsApi(this.extraProps);
+    }
+}
+exports.XataApiClient = XataApiClient;
+class UserApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    getUser() {
+        return components_1.operationsByTag.users.getUser(Object.assign({}, this.extraProps));
+    }
+    updateUser(user) {
+        return components_1.operationsByTag.users.updateUser(Object.assign({ body: user }, this.extraProps));
+    }
+    deleteUser() {
+        return components_1.operationsByTag.users.deleteUser(Object.assign({}, this.extraProps));
+    }
+    getUserAPIKeys() {
+        return components_1.operationsByTag.users.getUserAPIKeys(Object.assign({}, this.extraProps));
+    }
+    createUserAPIKey(keyName) {
+        return components_1.operationsByTag.users.createUserAPIKey(Object.assign({ pathParams: { keyName } }, this.extraProps));
+    }
+    deleteUserAPIKey(keyName) {
+        return components_1.operationsByTag.users.deleteUserAPIKey(Object.assign({ pathParams: { keyName } }, this.extraProps));
+    }
+}
+class WorkspaceApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    createWorkspace(workspaceMeta) {
+        return components_1.operationsByTag.workspaces.createWorkspace(Object.assign({ body: workspaceMeta }, this.extraProps));
+    }
+    getWorkspacesList() {
+        return components_1.operationsByTag.workspaces.getWorkspacesList(Object.assign({}, this.extraProps));
+    }
+    getWorkspace(workspaceId) {
+        return components_1.operationsByTag.workspaces.getWorkspace(Object.assign({ pathParams: { workspaceId } }, this.extraProps));
+    }
+    updateWorkspace(workspaceId, workspaceMeta) {
+        return components_1.operationsByTag.workspaces.updateWorkspace(Object.assign({ pathParams: { workspaceId }, body: workspaceMeta }, this.extraProps));
+    }
+    deleteWorkspace(workspaceId) {
+        return components_1.operationsByTag.workspaces.deleteWorkspace(Object.assign({ pathParams: { workspaceId } }, this.extraProps));
+    }
+    getWorkspaceMembersList(workspaceId) {
+        return components_1.operationsByTag.workspaces.getWorkspaceMembersList(Object.assign({ pathParams: { workspaceId } }, this.extraProps));
+    }
+    updateWorkspaceMemberRole(workspaceId, userId, role) {
+        return components_1.operationsByTag.workspaces.updateWorkspaceMemberRole(Object.assign({ pathParams: { workspaceId, userId }, body: { role } }, this.extraProps));
+    }
+    removeWorkspaceMember(workspaceId, userId) {
+        return components_1.operationsByTag.workspaces.removeWorkspaceMember(Object.assign({ pathParams: { workspaceId, userId } }, this.extraProps));
+    }
+    inviteWorkspaceMember(workspaceId, email, role) {
+        return components_1.operationsByTag.workspaces.inviteWorkspaceMember(Object.assign({ pathParams: { workspaceId }, body: { email, role } }, this.extraProps));
+    }
+    acceptWorkspaceMemberInvite(workspaceId, inviteKey) {
+        return components_1.operationsByTag.workspaces.acceptWorkspaceMemberInvite(Object.assign({ pathParams: { workspaceId, inviteKey } }, this.extraProps));
+    }
+}
+class DatabaseApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    getDatabaseList(workspace) {
+        return components_1.operationsByTag.database.getDatabaseList(Object.assign({ pathParams: { workspace } }, this.extraProps));
+    }
+    createDatabase(workspace, dbName, options = {}) {
+        return components_1.operationsByTag.database.createDatabase(Object.assign({ pathParams: { workspace, dbName }, body: options }, this.extraProps));
+    }
+    deleteDatabase(workspace, dbName) {
+        return components_1.operationsByTag.database.deleteDatabase(Object.assign({ pathParams: { workspace, dbName } }, this.extraProps));
+    }
+}
+class BranchApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    getBranchList(workspace, dbName) {
+        return components_1.operationsByTag.branch.getBranchList(Object.assign({ pathParams: { workspace, dbName } }, this.extraProps));
+    }
+    getBranchDetails(workspace, database, branch) {
+        return components_1.operationsByTag.branch.getBranchDetails(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` } }, this.extraProps));
+    }
+    createBranch(workspace, database, branch, from, options = {}) {
+        return components_1.operationsByTag.branch.createBranch(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, queryParams: { from }, body: options }, this.extraProps));
+    }
+    deleteBranch(workspace, database, branch) {
+        return components_1.operationsByTag.branch.deleteBranch(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` } }, this.extraProps));
+    }
+    updateBranchMetadata(workspace, database, branch, metadata = {}) {
+        return components_1.operationsByTag.branch.updateBranchMetadata(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, body: metadata }, this.extraProps));
+    }
+    getBranchMetadata(workspace, database, branch) {
+        return components_1.operationsByTag.branch.getBranchMetadata(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` } }, this.extraProps));
+    }
+    getBranchMigrationHistory(workspace, database, branch, options = {}) {
+        return components_1.operationsByTag.branch.getBranchMigrationHistory(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, body: options }, this.extraProps));
+    }
+    executeBranchMigrationPlan(workspace, database, branch, migrationPlan) {
+        return components_1.operationsByTag.branch.executeBranchMigrationPlan(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, body: migrationPlan }, this.extraProps));
+    }
+    getBranchMigrationPlan(workspace, database, branch, schema) {
+        return components_1.operationsByTag.branch.getBranchMigrationPlan(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, body: schema }, this.extraProps));
+    }
+    getBranchStats(workspace, database, branch) {
+        return components_1.operationsByTag.branch.getBranchStats(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` } }, this.extraProps));
+    }
+}
+class TableApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    createTable(workspace, database, branch, tableName) {
+        return components_1.operationsByTag.table.createTable(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName } }, this.extraProps));
+    }
+    deleteTable(workspace, database, branch, tableName) {
+        return components_1.operationsByTag.table.deleteTable(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName } }, this.extraProps));
+    }
+    updateTable(workspace, database, branch, tableName, options) {
+        return components_1.operationsByTag.table.updateTable(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: options }, this.extraProps));
+    }
+    getTableSchema(workspace, database, branch, tableName) {
+        return components_1.operationsByTag.table.getTableSchema(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName } }, this.extraProps));
+    }
+    setTableSchema(workspace, database, branch, tableName, options) {
+        return components_1.operationsByTag.table.setTableSchema(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: options }, this.extraProps));
+    }
+    getTableColumns(workspace, database, branch, tableName) {
+        return components_1.operationsByTag.table.getTableColumns(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName } }, this.extraProps));
+    }
+    addTableColumn(workspace, database, branch, tableName, column) {
+        return components_1.operationsByTag.table.addTableColumn(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: column }, this.extraProps));
+    }
+    getColumn(workspace, database, branch, tableName, columnName) {
+        return components_1.operationsByTag.table.getColumn(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName } }, this.extraProps));
+    }
+    deleteColumn(workspace, database, branch, tableName, columnName) {
+        return components_1.operationsByTag.table.deleteColumn(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName } }, this.extraProps));
+    }
+    updateColumn(workspace, database, branch, tableName, columnName, options) {
+        return components_1.operationsByTag.table.updateColumn(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName }, body: options }, this.extraProps));
+    }
+}
+class RecordsApi {
+    constructor(extraProps) {
+        this.extraProps = extraProps;
+    }
+    insertRecord(workspace, database, branch, tableName, record) {
+        return components_1.operationsByTag.records.insertRecord(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: record }, this.extraProps));
+    }
+    insertRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
+        return components_1.operationsByTag.records.insertRecordWithID(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId }, queryParams: options, body: record }, this.extraProps));
+    }
+    deleteRecord(workspace, database, branch, tableName, recordId) {
+        return components_1.operationsByTag.records.deleteRecord(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId } }, this.extraProps));
+    }
+    getRecord(workspace, database, branch, tableName, recordId, options = {}) {
+        return components_1.operationsByTag.records.getRecord(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId } }, this.extraProps));
+    }
+    bulkInsertTableRecords(workspace, database, branch, tableName, records) {
+        return components_1.operationsByTag.records.bulkInsertTableRecords(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: { records } }, this.extraProps));
+    }
+    queryTable(workspace, database, branch, tableName, query) {
+        return components_1.operationsByTag.records.queryTable(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName }, body: query }, this.extraProps));
+    }
+}