@xata.io/client 0.0.0-beta.c9e08d0 → 0.0.0-beta.ca9389a

package/dist/client.js

@@ -0,0 +1,124 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = exports.buildClient = exports.buildClientWithNamespaces = void 0;
+const schema_1 = require("./schema");
+const search_1 = require("./search");
+const branches_1 = require("./util/branches");
+const config_1 = require("./util/config");
+const fetch_1 = require("./util/fetch");
+const buildClientWithNamespaces = (namespaces) => () => (0, exports.buildClient)(namespaces);
+exports.buildClientWithNamespaces = buildClientWithNamespaces;
+const buildClient = (external) => {
+    var _instances, _branch, _parseOptions, _getFetchProps, _evaluateBranch, _a;
+    return _a = class {
+            constructor(options = {}, links) {
+                _instances.add(this);
+                _branch.set(this, void 0);
+                const safeOptions = __classPrivateFieldGet(this, _instances, "m", _parseOptions).call(this, options);
+                const namespaces = Object.assign({ db: new schema_1.SchemaNamespace(links), search: new search_1.SearchNamespace() }, external);
+                for (const [key, namespace] of Object.entries(namespaces)) {
+                    if (!namespace)
+                        continue;
+                    // @ts-ignore
+                    this[key] = namespace.build({ getFetchProps: () => __classPrivateFieldGet(this, _instances, "m", _getFetchProps).call(this, safeOptions) });
+                }
+            }
+        },
+        _branch = new WeakMap(),
+        _instances = new WeakSet(),
+        _parseOptions = function _parseOptions(options) {
+            const fetch = (0, fetch_1.getFetchImplementation)(options === null || options === void 0 ? void 0 : options.fetch);
+            const databaseURL = (options === null || options === void 0 ? void 0 : options.databaseURL) || (0, config_1.getDatabaseURL)();
+            const apiKey = (options === null || options === void 0 ? void 0 : options.apiKey) || (0, config_1.getAPIKey)();
+            const branch = () => __awaiter(this, void 0, void 0, function* () {
+                return (options === null || options === void 0 ? void 0 : options.branch)
+                    ? yield __classPrivateFieldGet(this, _instances, "m", _evaluateBranch).call(this, options.branch)
+                    : yield (0, config_1.getCurrentBranchName)({ apiKey, databaseURL, fetchImpl: options === null || options === void 0 ? void 0 : options.fetch });
+            });
+            if (!databaseURL || !apiKey) {
+                throw new Error('Options databaseURL and apiKey are required');
+            }
+            return { fetch, databaseURL, apiKey, branch };
+        },
+        _getFetchProps = function _getFetchProps({ fetch, apiKey, databaseURL, branch }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const branchValue = yield __classPrivateFieldGet(this, _instances, "m", _evaluateBranch).call(this, branch);
+                if (!branchValue)
+                    throw new Error('Unable to resolve branch value');
+                return {
+                    fetchImpl: fetch,
+                    apiKey,
+                    apiUrl: '',
+                    // Instead of using workspace and dbBranch, we inject a probably CNAME'd URL
+                    workspacesApiUrl: (path, params) => {
+                        var _a;
+                        const hasBranch = (_a = params.dbBranchName) !== null && _a !== void 0 ? _a : params.branch;
+                        const newPath = path.replace(/^\/db\/[^/]+/, hasBranch ? `:${branchValue}` : '');
+                        return databaseURL + newPath;
+                    }
+                };
+            });
+        },
+        _evaluateBranch = function _evaluateBranch(param) {
+            var e_1, _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                if (__classPrivateFieldGet(this, _branch, "f"))
+                    return __classPrivateFieldGet(this, _branch, "f");
+                if (!param)
+                    return undefined;
+                const strategies = Array.isArray(param) ? [...param] : [param];
+                const evaluateBranch = (strategy) => __awaiter(this, void 0, void 0, function* () {
+                    return (0, branches_1.isBranchStrategyBuilder)(strategy) ? yield strategy() : strategy;
+                });
+                try {
+                    for (var strategies_1 = __asyncValues(strategies), strategies_1_1; strategies_1_1 = yield strategies_1.next(), !strategies_1_1.done;) {
+                        const strategy = strategies_1_1.value;
+                        const branch = yield evaluateBranch(strategy);
+                        if (branch) {
+                            __classPrivateFieldSet(this, _branch, branch, "f");
+                            return branch;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (strategies_1_1 && !strategies_1_1.done && (_a = strategies_1.return)) yield _a.call(strategies_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            });
+        },
+        _a;
+};
+exports.buildClient = buildClient;
+class BaseClient extends (0, exports.buildClient)() {
+}
+exports.BaseClient = BaseClient;

package/dist/index.d.ts

@@ -1,186 +1,9 @@
-export interface XataRecord {
-    id: string;
-    xata: {
-        version: number;
-    };
-    read(): Promise<this>;
-    update(data: Selectable<this>): Promise<this>;
-    delete(): Promise<void>;
-}
-export declare type Queries<T> = {
-    [key in keyof T as T[key] extends Query<infer A, infer B> ? key : never]: T[key];
-};
-export declare type OmitQueries<T> = {
-    [key in keyof T as T[key] extends Query<infer A, infer B> ? never : key]: T[key];
-};
-export declare type OmitLinks<T> = {
-    [key in keyof T as T[key] extends XataRecord ? never : key]: T[key];
-};
-export declare type OmitMethods<T> = {
-    [key in keyof T as T[key] extends Function ? never : key]: T[key];
-};
-export declare type Selectable<T> = Omit<OmitQueries<OmitMethods<T>>, 'id' | 'xata'>;
-export declare type Select<T, K extends keyof T> = Pick<T, K> & Queries<T> & XataRecord;
-export declare type Include<T> = {
-    [key in keyof T as T[key] extends XataRecord ? key : never]?: boolean | Array<keyof Selectable<T[key]>>;
-};
-declare type SortDirection = 'asc' | 'desc';
-declare type Operator = '$gt' | '$lt' | '$ge' | '$le' | '$exists' | '$notExists' | '$endsWith' | '$startsWith' | '$pattern' | '$is' | '$isNot' | '$contains' | '$includes' | '$includesSubstring' | '$includesPattern' | '$includesAll';
-declare type Constraint<T> = {
-    [key in Operator]?: T;
-};
-declare type DeepConstraint<T> = T extends Record<string, any> ? {
-    [key in keyof T]?: T[key] | DeepConstraint<T[key]>;
-} : Constraint<T>;
-declare type ComparableType = number | Date;
-export declare const gt: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const ge: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const gte: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const lt: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const lte: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const le: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const exists: (column: string) => Constraint<string>;
-export declare const notExists: (column: string) => Constraint<string>;
-export declare const startsWith: (value: string) => Constraint<string>;
-export declare const endsWith: (value: string) => Constraint<string>;
-export declare const pattern: (value: string) => Constraint<string>;
-export declare const is: <T>(value: T) => Constraint<T>;
-export declare const isNot: <T>(value: T) => Constraint<T>;
-export declare const contains: <T>(value: T) => Constraint<T>;
-export declare const includes: (value: string) => Constraint<string>;
-export declare const includesSubstring: (value: string) => Constraint<string>;
-export declare const includesPattern: (value: string) => Constraint<string>;
-export declare const includesAll: (value: string) => Constraint<string>;
-declare type FilterConstraints<T> = {
-    [key in keyof T]?: T[key] extends Record<string, any> ? FilterConstraints<T[key]> : T[key] | DeepConstraint<T[key]>;
-};
-declare type CursorNavigationOptions = {
-    first?: string;
-} | {
-    last?: string;
-} | {
-    after?: string;
-    before?: string;
-};
-declare type OffsetNavigationOptions = {
-    size?: number;
-    offset?: number;
-};
-declare type PaginationOptions = CursorNavigationOptions & OffsetNavigationOptions;
-declare type BulkQueryOptions<T> = {
-    page?: PaginationOptions;
-};
-declare type QueryOrConstraint<T, R> = Query<T, R> | Constraint<T>;
-declare type QueryMeta = {
-    page: {
-        cursor: string;
-        more: boolean;
-    };
-};
-interface BasePage<T, R> {
-    query: Query<T, R>;
-    meta: QueryMeta;
-    records: R[];
-    nextPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    previousPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    firstPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    lastPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    hasNextPage(): boolean;
-}
-declare class Page<T, R> implements BasePage<T, R> {
-    readonly query: Query<T, R>;
-    readonly meta: QueryMeta;
-    readonly records: R[];
-    constructor(query: Query<T, R>, meta: QueryMeta, records?: R[]);
-    nextPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    previousPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    firstPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    lastPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    hasNextPage(): boolean;
-}
-export declare class Query<T, R = T> implements BasePage<T, R> {
-    table: string;
-    repository: Repository<T>;
-    readonly $any?: QueryOrConstraint<T, R>[];
-    readonly $all?: QueryOrConstraint<T, R>[];
-    readonly $not?: QueryOrConstraint<T, R>[];
-    readonly $none?: QueryOrConstraint<T, R>[];
-    readonly $sort?: Record<string, SortDirection>;
-    readonly query: Query<T, R>;
-    readonly meta: QueryMeta;
-    readonly records: R[];
-    constructor(repository: Repository<T> | null, table: string, data: Partial<Query<T, R>>, parent?: Query<T, R>);
-    any(...queries: Query<T, R>[]): Query<T, R>;
-    all(...queries: Query<T, R>[]): Query<T, R>;
-    not(...queries: Query<T, R>[]): Query<T, R>;
-    none(...queries: Query<T, R>[]): Query<T, R>;
-    filter(constraints: FilterConstraints<T>): Query<T, R>;
-    filter<F extends keyof T>(column: F, value: FilterConstraints<T[F]> | DeepConstraint<T[F]>): Query<T, R>;
-    sort<F extends keyof T>(column: F, direction: SortDirection): Query<T, R>;
-    getPaginated(options?: BulkQueryOptions<T>): Promise<Page<T, R>>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<R>;
-    getIterator(chunk: number, options?: Omit<BulkQueryOptions<T>, 'page'>): AsyncGenerator<R[]>;
-    getMany(options?: BulkQueryOptions<T>): Promise<R[]>;
-    getOne(options?: Omit<BulkQueryOptions<T>, 'page'>): Promise<R | null>;
-    deleteAll(): Promise<number>;
-    include(columns: Include<T>): this;
-    nextPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    previousPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    firstPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    lastPage(size?: number, offset?: number): Promise<Page<T, R>>;
-    hasNextPage(): boolean;
-}
-export declare abstract class Repository<T> extends Query<T, Selectable<T>> {
-    select<K extends keyof Selectable<T>>(...columns: K[]): Query<T, Select<T, K>>;
-    abstract create(object: Selectable<T>): Promise<T>;
-    abstract createMany(objects: Selectable<T>[]): Promise<T[]>;
-    abstract read(id: string): Promise<T | null>;
-    abstract update(id: string, object: Partial<T>): Promise<T>;
-    abstract delete(id: string): void;
-    abstract _runQuery<R>(query: Query<T, R>, options?: BulkQueryOptions<T>): Promise<Page<T, R>>;
-}
-export declare class RestRepository<T> extends Repository<T> {
-    client: BaseClient<any>;
-    fetch: any;
-    constructor(client: BaseClient<any>, table: string);
-    request<T>(method: string, path: string, body?: unknown): Promise<T | undefined>;
-    select<K extends keyof T>(...columns: K[]): Query<T, Select<T, K>>;
-    create(object: T): Promise<T>;
-    createMany(objects: T[]): Promise<T[]>;
-    read(id: string): Promise<T | null>;
-    update(id: string, object: Partial<T>): Promise<T>;
-    delete(id: string): Promise<void>;
-    _runQuery<R>(query: Query<T, R>, options?: BulkQueryOptions<T>): Promise<Page<T, R>>;
-}
-interface RepositoryFactory {
-    createRepository<T>(client: BaseClient<any>, table: string): Repository<T>;
-}
-export declare class RestRespositoryFactory implements RepositoryFactory {
-    createRepository<T>(client: BaseClient<any>, table: string): Repository<T>;
-}
-declare type BranchStrategyValue = string | undefined | null;
-declare type BranchStrategyBuilder = () => BranchStrategyValue | Promise<BranchStrategyValue>;
-declare type BranchStrategy = BranchStrategyValue | BranchStrategyBuilder;
-declare type BranchStrategyOption = NonNullable<BranchStrategy | BranchStrategy[]>;
-export declare type XataClientOptions = {
-    fetch?: unknown;
-    databaseURL?: string;
-    branch: BranchStrategyOption;
-    apiKey: string;
-    repositoryFactory?: RepositoryFactory;
-};
-export declare class BaseClient<D extends Record<string, Repository<any>>> {
-    options: XataClientOptions;
-    private links;
-    private branch;
-    db: D;
-    constructor(options: XataClientOptions, links: Links);
-    initObject<T>(table: string, object: object): T;
-    getBranch(): Promise<string>;
-}
 export declare class XataError extends Error {
     readonly status: number;
     constructor(message: string, status: number);
 }
-export declare type Links = Record<string, Array<string[]>>;
-export {};
+export * from './api';
+export * from './client';
+export * from './schema';
+export * from './search';
+export * from './util/config';