@xata.io/client 0.1.5 → 0.4.0

package/src/index.test.ts

@@ -1,222 +0,0 @@
-import { BaseClient, RestRepository, XataError, XataRecord } from './';
-
-const fetch = jest.fn();
-const client = new BaseClient(
-  {
-    fetch,
-    apiKey: '1234',
-    databaseURL: 'https://my-workspace-5df34do.staging.xatabase.co/db/xata:main'
-  },
-  {}
-);
-
-interface User extends XataRecord {
-  name: string;
-}
-
-const users = new RestRepository<User>(client, 'users');
-
-describe('request', () => {
-  test('builds the right arguments for a GET request', async () => {
-    fetch.mockReset().mockImplementation(() => {
-      return {
-        ok: true,
-        json: async () => ({})
-      };
-    });
-
-    users.request('GET', '/foo');
-
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch.mock.calls[0]).toMatchInlineSnapshot(`
-      Array [
-        "https://my-workspace-5df34do.staging.xatabase.co/db/xata:main/foo",
-        Object {
-          "body": undefined,
-          "headers": Object {
-            "Accept": "*/*",
-            "Authorization": "Bearer 1234",
-            "Content-Type": "application/json",
-          },
-          "method": "GET",
-        },
-      ]
-    `);
-  });
-
-  test('builds the right arguments for a POST request', async () => {
-    fetch.mockReset().mockImplementation(() => {
-      return {
-        ok: true,
-        json: async () => ({})
-      };
-    });
-
-    users.request('POST', '/foo', { a: 1 });
-
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch.mock.calls[0]).toMatchInlineSnapshot(`
-      Array [
-        "https://my-workspace-5df34do.staging.xatabase.co/db/xata:main/foo",
-        Object {
-          "body": "{\\"a\\":1}",
-          "headers": Object {
-            "Accept": "*/*",
-            "Authorization": "Bearer 1234",
-            "Content-Type": "application/json",
-          },
-          "method": "POST",
-        },
-      ]
-    `);
-  });
-
-  test('throws if the response is not ok', async () => {
-    fetch.mockImplementation(() => {
-      return {
-        ok: false,
-        status: 404,
-        statusText: 'Not Found'
-      };
-    });
-
-    expect(users.request('GET', '/foo')).rejects.toThrow(new XataError('Not Found', 404));
-  });
-
-  test('throws with the error from the server if the response is not ok', async () => {
-    fetch.mockImplementation(() => {
-      return {
-        ok: false,
-        status: 404,
-        statusText: 'Not Found',
-        json: async () => ({ message: 'Resource not found' })
-      };
-    });
-
-    expect(users.request('GET', '/foo')).rejects.toThrow(new XataError('Resource not found', 404));
-  });
-
-  test('returns the json body if the response is ok', async () => {
-    const json = { a: 1 };
-    fetch.mockImplementation(() => {
-      return {
-        ok: true,
-        json: async () => json
-      };
-    });
-
-    const result = await users.request('GET', '/foo');
-    expect(result).toEqual(json);
-  });
-});
-
-type ExpectedRequest = {
-  method: string;
-  path: string;
-  body: unknown;
-};
-
-async function expectRequest(expectedRequest: ExpectedRequest, callback: () => void, response?: unknown) {
-  const request = jest.fn(async () => response);
-  users.request = request;
-
-  await callback();
-
-  const { calls } = request.mock;
-  expect(calls.length).toBe(1);
-  const [method, path, body] = calls[0] as any;
-  expect(method).toBe(expectedRequest.method);
-  expect(path).toBe(expectedRequest.path);
-  expect(JSON.stringify(body)).toBe(JSON.stringify(expectedRequest.body));
-}
-
-describe('query', () => {
-  describe('getMany', () => {
-    test('simple query', async () => {
-      const expected = { method: 'POST', path: '/tables/users/query', body: {} };
-      expectRequest(expected, () => users.getMany(), { records: [] });
-    });
-
-    test('query with one filter', async () => {
-      const expected = { method: 'POST', path: '/tables/users/query', body: { filter: { $all: [{ name: 'foo' }] } } };
-      expectRequest(expected, () => users.filter('name', 'foo').getMany(), { records: [] });
-    });
-  });
-
-  describe('getOne', () => {
-    test('returns a single object', async () => {
-      const result = { records: [{ id: '1234' }] };
-      const expected = { method: 'POST', path: '/tables/users/query', body: {} };
-      expectRequest(
-        expected,
-        async () => {
-          const first = await users.select().getOne();
-          expect(first?.id).toBe(result.records[0].id);
-        },
-        result
-      );
-    });
-
-    test('returns null if no objects are returned', async () => {
-      const result = { records: [] };
-      const expected = { method: 'POST', path: '/tables/users/query', body: {} };
-      expectRequest(
-        expected,
-        async () => {
-          const first = await users.getOne();
-          expect(first).toBeNull();
-        },
-        result
-      );
-    });
-  });
-});
-
-describe('read', () => {
-  test('reads an object by id successfully', async () => {
-    const id = 'rec_1234';
-    const expected = { method: 'GET', path: `/tables/users/data/${id}`, body: undefined };
-    expectRequest(expected, () => users.read(id));
-  });
-});
-
-describe('Repository.update', () => {
-  test('updates and object successfully', async () => {
-    const object = { id: 'rec_1234', xata: { version: 1 }, name: 'Ada' } as User;
-    const expected = { method: 'PUT', path: `/tables/users/data/${object.id}`, body: object };
-    expectRequest(
-      expected,
-      async () => {
-        const result = await users.update(object.id, object);
-        expect(result.id).toBe(object.id);
-      },
-      { id: object.id }
-    );
-  });
-});
-describe('Repository.delete', () => {
-  test('deletes a record by id successfully', async () => {
-    const id = 'rec_1234';
-    const expected = { method: 'DELETE', path: `/tables/users/data/${id}`, body: undefined };
-    expectRequest(expected, async () => {
-      const result = await users.delete(id);
-      expect(result).toBe(undefined);
-    });
-  });
-});
-
-describe('create', () => {
-  test('successful', async () => {
-    const created = { id: 'rec_1234', _version: 0 };
-    const object = { name: 'Ada' } as User;
-    const expected = { method: 'POST', path: '/tables/users/data', body: object };
-    expectRequest(
-      expected,
-      async () => {
-        const result = await users.create(object);
-        expect(result.id).toBe(created.id);
-      },
-      created
-    );
-  });
-});

package/src/index.ts

@@ -1,468 +0,0 @@
-export interface XataRecord {
-  id: string;
-  xata: {
-    version: number;
-  };
-  read(): Promise<this>;
-  update(data: Selectable<this>): Promise<this>;
-  delete(): Promise<void>;
-}
-
-export type Queries<T> = {
-  [key in keyof T as T[key] extends Query<infer A, infer B> ? key : never]: T[key];
-};
-
-export type OmitQueries<T> = {
-  [key in keyof T as T[key] extends Query<infer A, infer B> ? never : key]: T[key];
-};
-
-export type OmitLinks<T> = {
-  [key in keyof T as T[key] extends XataRecord ? never : key]: T[key];
-};
-
-export type OmitMethods<T> = {
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  [key in keyof T as T[key] extends Function ? never : key]: T[key];
-};
-
-export type Selectable<T> = Omit<OmitQueries<OmitMethods<T>>, 'id' | 'xata'>;
-
-export type Select<T, K extends keyof T> = Pick<T, K> & Queries<T> & XataRecord;
-
-export type Include<T> = {
-  [key in keyof T as T[key] extends XataRecord ? key : never]?: boolean | Array<keyof Selectable<T[key]>>;
-};
-
-type SortDirection = 'asc' | 'desc';
-
-type Operator =
-  | '$gt'
-  | '$lt'
-  | '$ge'
-  | '$le'
-  | '$exists'
-  | '$notExists'
-  | '$endsWith'
-  | '$startsWith'
-  | '$pattern'
-  | '$is'
-  | '$isNot'
-  | '$contains'
-  | '$includes'
-  | '$includesSubstring'
-  | '$includesPattern'
-  | '$includesAll';
-
-// TODO: restrict constraints depending on type?
-// E.g. startsWith cannot be used with numbers
-type Constraint<T> = { [key in Operator]?: T };
-
-type DeepConstraint<T> = T extends Record<string, any>
-  ? {
-      [key in keyof T]?: T[key] | DeepConstraint<T[key]>;
-    }
-  : Constraint<T>;
-
-type ComparableType = number | Date;
-
-export const gt = <T extends ComparableType>(value: T): Constraint<T> => ({ $gt: value });
-export const ge = <T extends ComparableType>(value: T): Constraint<T> => ({ $ge: value });
-export const gte = <T extends ComparableType>(value: T): Constraint<T> => ({ $ge: value });
-export const lt = <T extends ComparableType>(value: T): Constraint<T> => ({ $lt: value });
-export const lte = <T extends ComparableType>(value: T): Constraint<T> => ({ $le: value });
-export const le = <T extends ComparableType>(value: T): Constraint<T> => ({ $le: value });
-export const exists = (column: string): Constraint<string> => ({ $exists: column });
-export const notExists = (column: string): Constraint<string> => ({ $notExists: column });
-export const startsWith = (value: string): Constraint<string> => ({ $startsWith: value });
-export const endsWith = (value: string): Constraint<string> => ({ $endsWith: value });
-export const pattern = (value: string): Constraint<string> => ({ $pattern: value });
-export const is = <T>(value: T): Constraint<T> => ({ $is: value });
-export const isNot = <T>(value: T): Constraint<T> => ({ $isNot: value });
-export const contains = <T>(value: T): Constraint<T> => ({ $contains: value });
-
-// TODO: these can only be applied to columns of type "multiple"
-export const includes = (value: string): Constraint<string> => ({ $includes: value });
-export const includesSubstring = (value: string): Constraint<string> => ({ $includesSubstring: value });
-export const includesPattern = (value: string): Constraint<string> => ({ $includesPattern: value });
-export const includesAll = (value: string): Constraint<string> => ({ $includesAll: value });
-
-type FilterConstraints<T> = {
-  [key in keyof T]?: T[key] extends Record<string, any> ? FilterConstraints<T[key]> : T[key] | DeepConstraint<T[key]>;
-};
-
-type BulkQueryOptions<T> = {
-  filter?: FilterConstraints<T>;
-  sort?:
-    | {
-        column: keyof T;
-        direction?: SortDirection;
-      }
-    | keyof T;
-};
-
-type QueryOrConstraint<T, R> = Query<T, R> | Constraint<T>;
-
-export 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>) {
-    if (repository) {
-      this.repository = repository;
-    } else {
-      this.repository = this as any;
-    }
-    this.table = table;
-
-    // For some reason Object.assign(this, parent) didn't work in this case
-    // so doing all this manually:
-    this.$any = parent?.$any;
-    this.$all = parent?.$all;
-    this.$not = parent?.$not;
-    this.$none = parent?.$none;
-    this.$sort = 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: Query<T, R>[]): Query<T, R> {
-    return new Query<T, R>(
-      this.repository,
-      this.table,
-      {
-        $any: (this.$any || []).concat(queries)
-      },
-      this
-    );
-  }
-
-  all(...queries: Query<T, R>[]): Query<T, R> {
-    return new Query<T, R>(
-      this.repository,
-      this.table,
-      {
-        $all: (this.$all || []).concat(queries)
-      },
-      this
-    );
-  }
-
-  not(...queries: Query<T, R>[]): Query<T, R> {
-    return new Query<T, R>(
-      this.repository,
-      this.table,
-      {
-        $not: (this.$not || []).concat(queries)
-      },
-      this
-    );
-  }
-
-  none(...queries: Query<T, R>[]): Query<T, R> {
-    return new Query<T, R>(
-      this.repository,
-      this.table,
-      {
-        $none: (this.$none || []).concat(queries)
-      },
-      this
-    );
-  }
-
-  filter(constraints: FilterConstraints<T>): Query<T, R>;
-  filter<F extends keyof T>(column: F, value: FilterConstraints<T[F]> | DeepConstraint<T[F]>): Query<T, R>;
-  filter(a: any, b?: any): Query<T, R> {
-    if (arguments.length === 1) {
-      const constraints = a as FilterConstraints<T>;
-      const queries: QueryOrConstraint<T, R>[] = [];
-      for (const [column, constraint] of Object.entries(constraints)) {
-        queries.push({ [column]: constraint });
-      }
-      return new Query<T, R>(
-        this.repository,
-        this.table,
-        {
-          $all: (this.$all || []).concat(queries)
-        },
-        this
-      );
-    } else {
-      const column = a as keyof T;
-      const value = b as Partial<T[keyof T]> | Constraint<T[keyof T]>;
-      return new Query<T, R>(
-        this.repository,
-        this.table,
-        {
-          $all: (this.$all || []).concat({ [column]: value })
-        },
-        this
-      );
-    }
-  }
-
-  sort<F extends keyof T>(column: F, direction: SortDirection): Query<T, R> {
-    const sort = { ...this.$sort, [column]: direction };
-    const q = new Query<T, R>(
-      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.
-  async getMany(options?: BulkQueryOptions<T>): Promise<R[]> {
-    // TODO: use options
-    return this.repository.query(this);
-  }
-
-  async getOne(options?: BulkQueryOptions<T>): Promise<R | null> {
-    // TODO: use options
-    const arr = await this.getMany(); // TODO, limit to 1
-    return arr[0] || null;
-  }
-
-  async deleteAll(): Promise<number> {
-    // Return number of affected rows
-    return 0;
-  }
-
-  include(columns: Include<T>) {
-    // TODO
-    return this;
-  }
-}
-
-export abstract class Repository<T> extends Query<T, Selectable<T>> {
-  select<K extends keyof Selectable<T>>(...columns: K[]) {
-    return new Query<T, Select<T, K>>(this.repository, this.table, {});
-  }
-
-  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;
-
-  // Used by the Query object internally
-  abstract query<R>(query: Query<T, R>): Promise<R[]>;
-}
-
-export class RestRepository<T> extends Repository<T> {
-  client: BaseClient<any>;
-  fetch: any;
-
-  constructor(client: BaseClient<any>, table: string) {
-    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 });
-  }
-
-  async request(method: string, path: string, body?: unknown) {
-    const { databaseURL } = this.client.options;
-    const resp: Response = await this.fetch(`${databaseURL}${path}`, {
-      method,
-      headers: {
-        Accept: '*/*',
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.client.options.apiKey}`
-      },
-      body: JSON.stringify(body)
-    });
-    if (!resp.ok) {
-      try {
-        const json = await 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<K extends keyof T>(...columns: K[]) {
-    return new Query<T, Select<T, K>>(this.repository, this.table, {});
-  }
-
-  async create(object: T): Promise<T> {
-    const body = { ...object } as Record<string, unknown>;
-    for (const key of Object.keys(body)) {
-      const value = body[key];
-      if (value && typeof value === 'object' && typeof (value as Record<string, unknown>).id === 'string') {
-        body[key] = (value as XataRecord).id;
-      }
-    }
-    const obj = await this.request('POST', `/tables/${this.table}/data`, body);
-    return this.client.initObject(this.table, obj);
-  }
-
-  async read(id: string): Promise<T | null> {
-    try {
-      const obj = await this.request('GET', `/tables/${this.table}/data/${id}`);
-      return this.client.initObject(this.table, obj);
-    } catch (err) {
-      if ((err as XataError).status === 404) return null;
-      throw err;
-    }
-  }
-
-  async update(id: string, object: Partial<T>): Promise<T> {
-    const obj = await this.request('PUT', `/tables/${this.table}/data/${id}`, object);
-    return this.client.initObject(this.table, obj);
-  }
-
-  async delete(id: string) {
-    await this.request('DELETE', `/tables/${this.table}/data/${id}`);
-  }
-
-  async query<R>(query: Query<T, R>): Promise<R[]> {
-    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 = await this.request('POST', `/tables/${this.table}/query`, body);
-    return result.records.map((record: object) => this.client.initObject(this.table, record));
-  }
-}
-
-interface RepositoryFactory {
-  createRepository<T>(client: BaseClient<any>, table: string): Repository<T>;
-}
-
-export class RestRespositoryFactory implements RepositoryFactory {
-  createRepository<T>(client: BaseClient<any>, table: string): Repository<T> {
-    return new RestRepository<T>(client, table);
-  }
-}
-
-export type XataClientOptions = {
-  fetch?: unknown;
-  databaseURL: string;
-  apiKey: string;
-  repositoryFactory?: RepositoryFactory;
-};
-
-export class BaseClient<D extends Record<string, Repository<any>>> {
-  options: XataClientOptions;
-  private links: Links;
-  db!: D;
-
-  constructor(options: XataClientOptions, links: Links) {
-    this.options = options;
-    this.links = links;
-  }
-
-  public initObject<T>(table: string, object: object) {
-    const o: Record<string, unknown> = {};
-    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 as any;
-        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'] as string);
-    };
-    o.update = function (data: any) {
-      return db[table].update(o['id'] as string, data);
-    };
-    o.delete = function () {
-      return db[table].delete(o['id'] as string);
-    };
-
-    for (const prop of ['read', 'update', 'delete']) {
-      Object.defineProperty(o, prop, { enumerable: false });
-    }
-
-    // TODO: links and rev links
-
-    Object.freeze(o);
-    return o as T;
-  }
-}
-
-export class XataError extends Error {
-  readonly status: number;
-
-  constructor(message: string, status: number) {
-    super(message);
-    this.status = status;
-  }
-}
-
-export type Links = Record<string, Array<string[]>>;