@xata.io/client 0.0.0-beta.123dd7a → 0.0.0-beta.14375f7

package/dist/index.d.ts

@@ -1,137 +1,6 @@
-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 BulkQueryOptions<T> = {
-    filter?: FilterConstraints<T>;
-    sort?: {
-        column: keyof T;
-        direction?: SortDirection;
-    } | keyof T;
-};
-declare type QueryOrConstraint<T, R> = Query<T, R> | Constraint<T>;
-export declare class Query<T, R = T> {
-    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>;
-    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>;
-    getMany(options?: BulkQueryOptions<T>): Promise<R[]>;
-    getOne(options?: BulkQueryOptions<T>): Promise<R | null>;
-    deleteAll(): Promise<number>;
-    include(columns: Include<T>): this;
-}
-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 read(id: string): Promise<T | null>;
-    abstract update(id: string, object: Partial<T>): Promise<T>;
-    abstract delete(id: string): void;
-    abstract query<R>(query: Query<T, R>): Promise<R[]>;
-}
-export declare class RestRepository<T> extends Repository<T> {
-    client: BaseClient<any>;
-    fetch: any;
-    constructor(client: BaseClient<any>, table: string);
-    request(method: string, path: string, body?: unknown): Promise<any>;
-    select<K extends keyof T>(...columns: K[]): Query<T, Select<T, K>>;
-    create(object: T): Promise<T>;
-    read(id: string): Promise<T | null>;
-    update(id: string, object: Partial<T>): Promise<T>;
-    delete(id: string): Promise<void>;
-    query<R>(query: Query<T, R>): Promise<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 './schema';

package/dist/index.js

@@ -1,371 +1,20 @@
 "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 __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); }
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XataError = exports.BaseClient = exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = exports.Query = exports.includesAll = exports.includesPattern = exports.includesSubstring = exports.includes = exports.contains = exports.isNot = exports.is = exports.pattern = exports.endsWith = exports.startsWith = exports.notExists = exports.exists = exports.le = exports.lte = exports.lt = exports.gte = exports.ge = exports.gt = void 0;
-const gt = (value) => ({ $gt: value });
-exports.gt = gt;
-const ge = (value) => ({ $ge: value });
-exports.ge = ge;
-const gte = (value) => ({ $ge: value });
-exports.gte = gte;
-const lt = (value) => ({ $lt: value });
-exports.lt = lt;
-const lte = (value) => ({ $le: value });
-exports.lte = lte;
-const le = (value) => ({ $le: value });
-exports.le = le;
-const exists = (column) => ({ $exists: column });
-exports.exists = exists;
-const notExists = (column) => ({ $notExists: column });
-exports.notExists = notExists;
-const startsWith = (value) => ({ $startsWith: value });
-exports.startsWith = startsWith;
-const endsWith = (value) => ({ $endsWith: value });
-exports.endsWith = endsWith;
-const pattern = (value) => ({ $pattern: value });
-exports.pattern = pattern;
-const is = (value) => ({ $is: value });
-exports.is = is;
-const isNot = (value) => ({ $isNot: value });
-exports.isNot = isNot;
-const contains = (value) => ({ $contains: value });
-exports.contains = contains;
-// TODO: these can only be applied to columns of type "multiple"
-const includes = (value) => ({ $includes: value });
-exports.includes = includes;
-const includesSubstring = (value) => ({ $includesSubstring: value });
-exports.includesSubstring = includesSubstring;
-const includesPattern = (value) => ({ $includesPattern: value });
-exports.includesPattern = includesPattern;
-const includesAll = (value) => ({ $includesAll: value });
-exports.includesAll = includesAll;
-class Query {
-    constructor(repository, table, data, parent) {
-        if (repository) {
-            this.repository = repository;
-        }
-        else {
-            this.repository = this;
-        }
-        this.table = table;
-        // For some reason Object.assign(this, parent) didn't work in this case
-        // so doing all this manually:
-        this.$any = parent === null || parent === void 0 ? void 0 : parent.$any;
-        this.$all = parent === null || parent === void 0 ? void 0 : parent.$all;
-        this.$not = parent === null || parent === void 0 ? void 0 : parent.$not;
-        this.$none = parent === null || parent === void 0 ? void 0 : parent.$none;
-        this.$sort = parent === null || parent === void 0 ? void 0 : parent.$sort;
-        Object.assign(this, data);
-        // These bindings are used to support deconstructing
-        // const { any, not, filter, sort } = xata.users.query()
-        this.any = this.any.bind(this);
-        this.all = this.all.bind(this);
-        this.not = this.not.bind(this);
-        this.filter = this.filter.bind(this);
-        this.sort = this.sort.bind(this);
-        this.none = this.none.bind(this);
-        Object.defineProperty(this, 'table', { enumerable: false });
-        Object.defineProperty(this, 'repository', { enumerable: false });
-    }
-    any(...queries) {
-        return new Query(this.repository, this.table, {
-            $any: (this.$any || []).concat(queries)
-        }, this);
-    }
-    all(...queries) {
-        return new Query(this.repository, this.table, {
-            $all: (this.$all || []).concat(queries)
-        }, this);
-    }
-    not(...queries) {
-        return new Query(this.repository, this.table, {
-            $not: (this.$not || []).concat(queries)
-        }, this);
-    }
-    none(...queries) {
-        return new Query(this.repository, this.table, {
-            $none: (this.$none || []).concat(queries)
-        }, this);
-    }
-    filter(a, b) {
-        if (arguments.length === 1) {
-            const constraints = a;
-            const queries = [];
-            for (const [column, constraint] of Object.entries(constraints)) {
-                queries.push({ [column]: constraint });
-            }
-            return new Query(this.repository, this.table, {
-                $all: (this.$all || []).concat(queries)
-            }, this);
-        }
-        else {
-            const column = a;
-            const value = b;
-            return new Query(this.repository, this.table, {
-                $all: (this.$all || []).concat({ [column]: value })
-            }, this);
-        }
-    }
-    sort(column, direction) {
-        const sort = Object.assign(Object.assign({}, this.$sort), { [column]: direction });
-        const q = new Query(this.repository, this.table, {
-            $sort: sort
-        }, this);
-        return q;
-    }
-    // TODO: pagination. Maybe implement different methods for different type of paginations
-    // and one to simply get the first records returned by the query with no pagination.
-    getMany(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: use options
-            return this.repository.query(this);
-        });
-    }
-    getOne(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: use options
-            const arr = yield this.getMany(); // TODO, limit to 1
-            return arr[0] || null;
-        });
-    }
-    deleteAll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Return number of affected rows
-            return 0;
-        });
-    }
-    include(columns) {
-        // TODO
-        return this;
-    }
-}
-exports.Query = Query;
-class Repository extends Query {
-    select(...columns) {
-        return new Query(this.repository, this.table, {});
-    }
-}
-exports.Repository = Repository;
-class RestRepository extends Repository {
-    constructor(client, table) {
-        super(null, table, {});
-        this.client = client;
-        const { fetch } = client.options;
-        if (fetch) {
-            this.fetch = fetch;
-        }
-        else if (typeof window === 'object') {
-            this.fetch = window.fetch;
-        }
-        else if (typeof require === 'function') {
-            try {
-                this.fetch = require('node-fetch');
-            }
-            catch (err) {
-                try {
-                    this.fetch = require('cross-fetch');
-                }
-                catch (err) {
-                    throw new Error('No fetch implementation found. Please provide one in the constructor');
-                }
-            }
-        }
-        Object.defineProperty(this, 'client', { enumerable: false });
-        Object.defineProperty(this, 'fetch', { enumerable: false });
-        Object.defineProperty(this, 'hostname', { enumerable: false });
-    }
-    request(method, path, body) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { databaseURL, apiKey } = this.client.options;
-            const branch = yield this.client.getBranch();
-            const resp = yield this.fetch(`${databaseURL}:${branch}${path}`, {
-                method,
-                headers: {
-                    Accept: '*/*',
-                    'Content-Type': 'application/json',
-                    Authorization: `Bearer ${apiKey}`
-                },
-                body: JSON.stringify(body)
-            });
-            if (!resp.ok) {
-                try {
-                    const json = yield resp.json();
-                    const message = json.message;
-                    if (typeof message === 'string') {
-                        throw new XataError(message, resp.status);
-                    }
-                }
-                catch (err) {
-                    if (err instanceof XataError)
-                        throw err;
-                    // Ignore errors for other reasons.
-                    // For example if the response's body cannot be parsed as JSON
-                }
-                throw new XataError(resp.statusText, resp.status);
-            }
-            if (resp.status === 204)
-                return;
-            return resp.json();
-        });
-    }
-    select(...columns) {
-        return new Query(this.repository, this.table, {});
-    }
-    create(object) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const body = Object.assign({}, object);
-            for (const key of Object.keys(body)) {
-                const value = body[key];
-                if (value && typeof value === 'object' && typeof value.id === 'string') {
-                    body[key] = value.id;
-                }
-            }
-            const obj = yield this.request('POST', `/tables/${this.table}/data`, body);
-            return this.client.initObject(this.table, obj);
-        });
-    }
-    read(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const obj = yield this.request('GET', `/tables/${this.table}/data/${id}`);
-                return this.client.initObject(this.table, obj);
-            }
-            catch (err) {
-                if (err.status === 404)
-                    return null;
-                throw err;
-            }
-        });
-    }
-    update(id, object) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const obj = yield this.request('PUT', `/tables/${this.table}/data/${id}`, object);
-            return this.client.initObject(this.table, obj);
-        });
-    }
-    delete(id) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.request('DELETE', `/tables/${this.table}/data/${id}`);
-        });
-    }
-    query(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const filter = {
-                $any: query.$any,
-                $all: query.$all,
-                $not: query.$not,
-                $none: query.$none
-            };
-            const body = {
-                filter: Object.values(filter).some(Boolean) ? filter : undefined,
-                sort: query.$sort
-            };
-            const result = yield this.request('POST', `/tables/${this.table}/query`, body);
-            return result.records.map((record) => this.client.initObject(this.table, record));
-        });
-    }
-}
-exports.RestRepository = RestRepository;
-class RestRespositoryFactory {
-    createRepository(client, table) {
-        return new RestRepository(client, table);
-    }
-}
-exports.RestRespositoryFactory = RestRespositoryFactory;
-class BaseClient {
-    constructor(options, links) {
-        if (!options.databaseURL || !options.apiKey || !options.branch) {
-            throw new Error('Options databaseURL, apiKey and branch are required');
-        }
-        this.options = options;
-        this.links = links;
-    }
-    initObject(table, object) {
-        const o = {};
-        Object.assign(o, object);
-        const tableLinks = this.links[table] || [];
-        for (const link of tableLinks) {
-            const [field, linkTable] = link;
-            const value = o[field];
-            if (value && typeof value === 'object') {
-                const { id } = value;
-                if (Object.keys(value).find((col) => col === 'id')) {
-                    o[field] = this.initObject(linkTable, value);
-                }
-                else if (id) {
-                    o[field] = {
-                        id,
-                        get: () => {
-                            this.db[linkTable].read(id);
-                        }
-                    };
-                }
-            }
-        }
-        const db = this.db;
-        o.read = function () {
-            return db[table].read(o['id']);
-        };
-        o.update = function (data) {
-            return db[table].update(o['id'], data);
-        };
-        o.delete = function () {
-            return db[table].delete(o['id']);
-        };
-        for (const prop of ['read', 'update', 'delete']) {
-            Object.defineProperty(o, prop, { enumerable: false });
-        }
-        // TODO: links and rev links
-        Object.freeze(o);
-        return o;
-    }
-    getBranch() {
-        var e_1, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.branch)
-                return this.branch;
-            const { branch: param } = this.options;
-            const strategies = Array.isArray(param) ? [...param] : [param];
-            const evaluateBranch = (strategy) => __awaiter(this, void 0, void 0, function* () {
-                return 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) {
-                        this.branch = branch;
-                        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; }
-            }
-            throw new Error('Unable to resolve branch value');
-        });
-    }
-}
-exports.BaseClient = BaseClient;
+exports.XataError = void 0;
 class XataError extends Error {
     constructor(message, status) {
         super(message);
@@ -373,6 +22,5 @@ class XataError extends Error {
     }
 }
 exports.XataError = XataError;
-const isBranchStrategyBuilder = (strategy) => {
-    return typeof strategy === 'function';
-};
+__exportStar(require("./api"), exports);
+__exportStar(require("./schema"), exports);

package/dist/schema/config.d.ts

@@ -0,0 +1,4 @@
+import { FetcherExtraProps } from '../api/fetcher';
+export declare function getBranch(fetchProps: Omit<FetcherExtraProps, 'workspacesApiUrl'>): Promise<string | undefined>;
+export declare function getDatabaseUrl(): string | undefined;
+export declare function getAPIKey(): string | undefined;

package/dist/schema/config.js

@@ -0,0 +1,83 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAPIKey = exports.getDatabaseUrl = exports.getBranch = void 0;
+const api_1 = require("../api");
+const environment_1 = require("../util/environment");
+const lang_1 = require("../util/lang");
+const envBranchNames = [
+    'XATA_BRANCH',
+    'VERCEL_GIT_COMMIT_REF',
+    'CF_PAGES_BRANCH',
+    'BRANCH' // Netlify. Putting it the last one because it is more ambiguous
+];
+function getBranch(fetchProps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const env = getBranchByEnvVariable();
+        if (env)
+            return env;
+        const branch = yield (0, environment_1.getGitBranch)();
+        if (!branch)
+            return undefined;
+        // TODO: in the future, call /resolve endpoint
+        // For now, call API to see if the branch exists. If not, use a default value.
+        const [protocol, , host, , database] = fetchProps.apiUrl.split('/');
+        const [workspace] = host.split('.');
+        const dbBranchName = `${database}:${branch}`;
+        try {
+            yield (0, api_1.getBranchDetails)(Object.assign(Object.assign({}, fetchProps), { workspacesApiUrl: `${protocol}//${host}`, pathParams: {
+                    dbBranchName,
+                    workspace
+                } }));
+        }
+        catch (err) {
+            if ((0, lang_1.isObject)(err) && err.status === 404)
+                return 'main';
+            throw err;
+        }
+        return branch;
+    });
+}
+exports.getBranch = getBranch;
+function getBranchByEnvVariable() {
+    for (const name of envBranchNames) {
+        const value = (0, environment_1.getEnvVariable)(name);
+        if (value) {
+            return value;
+        }
+    }
+    try {
+        return XATA_BRANCH;
+    }
+    catch (err) {
+        // Ignore ReferenceError. Only CloudFlare workers set env variables as global variables
+    }
+}
+function getDatabaseUrl() {
+    var _a;
+    try {
+        return (_a = (0, environment_1.getEnvVariable)('XATA_DATABASE_URL')) !== null && _a !== void 0 ? _a : XATA_DATABASE_URL;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+exports.getDatabaseUrl = getDatabaseUrl;
+function getAPIKey() {
+    var _a;
+    try {
+        return (_a = (0, environment_1.getEnvVariable)('XATA_API_KEY')) !== null && _a !== void 0 ? _a : XATA_API_KEY;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+exports.getAPIKey = getAPIKey;