@tapstack/db 1.0.0

package/dist/core/src/client.d.ts

@@ -0,0 +1,21 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
+export interface RequestInterceptor {
+    onFulfilled?: (value: InternalAxiosRequestConfig) => InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>;
+    onRejected?: (error: any) => any;
+}
+export interface ResponseInterceptor {
+    onFulfilled?: (value: AxiosResponse) => AxiosResponse | Promise<AxiosResponse>;
+    onRejected?: (error: any) => any;
+}
+export interface BaseClientConfig extends AxiosRequestConfig {
+    baseURL: string;
+    apiKey: string;
+    /** Custom request interceptors */
+    requestInterceptors?: RequestInterceptor[];
+    /** Custom response interceptors */
+    responseInterceptors?: ResponseInterceptor[];
+}
+export declare class BaseClient {
+    protected readonly client: AxiosInstance;
+    constructor(config: BaseClientConfig);
+}

package/dist/core/src/client.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class BaseClient {
+    constructor(config) {
+        const { apiKey, requestInterceptors, responseInterceptors, ...axiosConfig } = config;
+        this.client = axios_1.default.create({
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+                ...(axiosConfig.headers || {})
+            },
+            ...axiosConfig
+        });
+        requestInterceptors?.forEach((interceptor) => {
+            this.client.interceptors.request.use(interceptor.onFulfilled, interceptor.onRejected);
+        });
+        responseInterceptors?.forEach((interceptor) => {
+            this.client.interceptors.response.use(interceptor.onFulfilled, interceptor.onRejected);
+        });
+    }
+}
+exports.BaseClient = BaseClient;

package/dist/core/src/index.d.ts

@@ -0,0 +1 @@
+export * from './client';

package/dist/core/src/index.js

@@ -0,0 +1,17 @@
+"use strict";
+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 });
+__exportStar(require("./client"), exports);

package/dist/db/src/__tests__/client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/db/src/__tests__/client.test.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("../index");
+jest.mock('axios');
+const mockedCreate = axios_1.default.create;
+describe('TapstackDBClient', () => {
+    const apiClient = {
+        get: jest.fn(),
+        post: jest.fn(),
+        put: jest.fn(),
+        delete: jest.fn(),
+    };
+    let client;
+    beforeEach(() => {
+        mockedCreate.mockReturnValue(apiClient);
+        client = new index_1.TapstackDBClient({ baseURL: 'http://example.com', apiKey: 'token' });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('getObject calls axios.get with correct path', async () => {
+        await client.getObject('item');
+        expect(apiClient.get).toHaveBeenCalledWith('/system/item');
+    });
+    it('getAllObjects calls axios.get on /system', async () => {
+        await client.getAllObjects();
+        expect(apiClient.get).toHaveBeenCalledWith('/system');
+    });
+    it('createObject posts to /system', async () => {
+        const data = { name: 'test' };
+        await client.createObject(data);
+        expect(apiClient.post).toHaveBeenCalledWith('/system', data);
+    });
+    it('updateObject puts to correct path', async () => {
+        await client.updateObject('item', { a: 1 });
+        expect(apiClient.put).toHaveBeenCalledWith('/system/item', { a: 1 });
+    });
+    it('deleteObject deletes from correct path', async () => {
+        await client.deleteObject('item');
+        expect(apiClient.delete).toHaveBeenCalledWith('/system/item');
+    });
+    it('getFields calls axios.get with fields path', async () => {
+        await client.getFields('item');
+        expect(apiClient.get).toHaveBeenCalledWith('/system/item/fields');
+    });
+    it('getField calls axios.get with field id', async () => {
+        await client.getField('item', '1');
+        expect(apiClient.get).toHaveBeenCalledWith('/system/item/fields/1');
+    });
+    it('createField posts to fields path', async () => {
+        await client.createField('item', { name: 'field' });
+        expect(apiClient.post).toHaveBeenCalledWith('/system/item/fields', { name: 'field' });
+    });
+    it('updateField puts to specific field path', async () => {
+        await client.updateField('item', '1', { name: 'f' });
+        expect(apiClient.put).toHaveBeenCalledWith('/system/item/fields/1', { name: 'f' });
+    });
+    it('deleteField deletes the field path', async () => {
+        await client.deleteField('item', '1');
+        expect(apiClient.delete).toHaveBeenCalledWith('/system/item/fields/1');
+    });
+    it('query posts to slug', async () => {
+        const variables = { a: 1 };
+        await client.query('item', variables);
+        expect(apiClient.post).toHaveBeenCalledWith('/item', variables);
+    });
+});

package/dist/db/src/index.d.ts

@@ -0,0 +1,29 @@
+export * from './types';
+export * from './modules/objects';
+export * from './modules/fields';
+export * from './modules/records';
+import { AxiosResponse } from 'axios';
+import { BaseClient, BaseClientConfig } from '@tapstack/core';
+import { ObjectModule } from './modules/objects';
+import { FieldModule } from './modules/fields';
+import { RecordModule } from './modules/records';
+import { CreateFieldPayload, CreateObjectPayload } from './types';
+export interface TapstackDBClientConfig extends BaseClientConfig {
+}
+export declare class TapstackDBClient extends BaseClient {
+    readonly objects: ObjectModule;
+    readonly fields: FieldModule;
+    readonly records: RecordModule;
+    constructor(config: TapstackDBClientConfig);
+    getObject(slug: string): Promise<AxiosResponse<any>>;
+    getAllObjects(): Promise<AxiosResponse<any>>;
+    createObject(data: CreateObjectPayload): Promise<AxiosResponse<any>>;
+    updateObject(slug: string, data: Partial<CreateObjectPayload>): Promise<AxiosResponse<any>>;
+    deleteObject(slug: string): Promise<AxiosResponse<any>>;
+    getFields(slug: string): Promise<AxiosResponse<any>>;
+    getField(slug: string, fieldID: string): Promise<AxiosResponse<any>>;
+    createField(slug: string, data: CreateFieldPayload): Promise<AxiosResponse<any>>;
+    updateField(slug: string, fieldID: string, data: Partial<CreateFieldPayload>): Promise<AxiosResponse<any>>;
+    deleteField(slug: string, fieldID: string): Promise<AxiosResponse<any>>;
+    query(slug: string, variables: any): Promise<AxiosResponse<any>>;
+}

package/dist/db/src/index.js

@@ -0,0 +1,67 @@
+"use strict";
+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.TapstackDBClient = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./modules/objects"), exports);
+__exportStar(require("./modules/fields"), exports);
+__exportStar(require("./modules/records"), exports);
+const core_1 = require("@tapstack/core");
+const objects_1 = require("./modules/objects");
+const fields_1 = require("./modules/fields");
+const records_1 = require("./modules/records");
+class TapstackDBClient extends core_1.BaseClient {
+    constructor(config) {
+        super(config);
+        this.objects = new objects_1.ObjectModule(this.client);
+        this.fields = new fields_1.FieldModule(this.client);
+        this.records = new records_1.RecordModule(this.client);
+    }
+    async getObject(slug) {
+        return this.client.get(`/system/${slug}`);
+    }
+    async getAllObjects() {
+        return this.client.get(`/system`);
+    }
+    async createObject(data) {
+        return this.client.post(`/system`, data);
+    }
+    async updateObject(slug, data) {
+        return this.client.put(`/system/${slug}`, data);
+    }
+    async deleteObject(slug) {
+        return this.client.delete(`/system/${slug}`);
+    }
+    async getFields(slug) {
+        return this.client.get(`/system/${slug}/fields`);
+    }
+    async getField(slug, fieldID) {
+        return this.client.get(`/system/${slug}/fields/${fieldID}`);
+    }
+    async createField(slug, data) {
+        return this.client.post(`/system/${slug}/fields`, data);
+    }
+    async updateField(slug, fieldID, data) {
+        return this.client.put(`/system/${slug}/fields/${fieldID}`, data);
+    }
+    async deleteField(slug, fieldID) {
+        return this.client.delete(`/system/${slug}/fields/${fieldID}`);
+    }
+    async query(slug, variables) {
+        return this.client.post(`/${slug}`, variables);
+    }
+}
+exports.TapstackDBClient = TapstackDBClient;

package/dist/db/src/modules/fields.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from 'axios';
+import { TapstackField, TapstackResponse } from '../types';
+export declare class FieldModule {
+    private client;
+    constructor(client: AxiosInstance);
+    list(slug: string): Promise<TapstackResponse<TapstackField[]>>;
+    get(slug: string, fieldID: string): Promise<TapstackResponse<TapstackField>>;
+    create(slug: string, data: Partial<TapstackField>): Promise<TapstackResponse<TapstackField>>;
+    update(slug: string, fieldID: string, data: Partial<TapstackField>): Promise<TapstackResponse<TapstackField>>;
+    delete(slug: string, fieldID: string): Promise<TapstackResponse<void>>;
+}

package/dist/db/src/modules/fields.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldModule = void 0;
+const request_1 = require("../request");
+class FieldModule {
+    constructor(client) {
+        this.client = client;
+    }
+    list(slug) {
+        return (0, request_1.handleRequest)(this.client, { method: 'GET', url: `/system/${slug}/fields` });
+    }
+    get(slug, fieldID) {
+        return (0, request_1.handleRequest)(this.client, { method: 'GET', url: `/system/${slug}/fields/${fieldID}` });
+    }
+    create(slug, data) {
+        return (0, request_1.handleRequest)(this.client, { method: 'POST', url: `/system/${slug}/fields`, data });
+    }
+    update(slug, fieldID, data) {
+        return (0, request_1.handleRequest)(this.client, { method: 'PUT', url: `/system/${slug}/fields/${fieldID}`, data });
+    }
+    delete(slug, fieldID) {
+        return (0, request_1.handleRequest)(this.client, { method: 'DELETE', url: `/system/${slug}/fields/${fieldID}` });
+    }
+}
+exports.FieldModule = FieldModule;

package/dist/db/src/modules/objects.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from 'axios';
+import { TapstackObject, TapstackResponse } from '../types';
+export declare class ObjectModule {
+    private client;
+    constructor(client: AxiosInstance);
+    get(slug: string): Promise<TapstackResponse<TapstackObject>>;
+    list(): Promise<TapstackResponse<TapstackObject[]>>;
+    create(data: Partial<TapstackObject>): Promise<TapstackResponse<TapstackObject>>;
+    update(slug: string, data: Partial<TapstackObject>): Promise<TapstackResponse<TapstackObject>>;
+    delete(slug: string): Promise<TapstackResponse<void>>;
+}

package/dist/db/src/modules/objects.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectModule = void 0;
+const request_1 = require("../request");
+class ObjectModule {
+    constructor(client) {
+        this.client = client;
+    }
+    get(slug) {
+        return (0, request_1.handleRequest)(this.client, { method: 'GET', url: `/system/${slug}` });
+    }
+    list() {
+        return (0, request_1.handleRequest)(this.client, { method: 'GET', url: `/system` });
+    }
+    create(data) {
+        return (0, request_1.handleRequest)(this.client, { method: 'POST', url: `/system`, data });
+    }
+    update(slug, data) {
+        return (0, request_1.handleRequest)(this.client, { method: 'PUT', url: `/system/${slug}`, data });
+    }
+    delete(slug) {
+        return (0, request_1.handleRequest)(this.client, { method: 'DELETE', url: `/system/${slug}` });
+    }
+}
+exports.ObjectModule = ObjectModule;

package/dist/db/src/modules/records.d.ts

@@ -0,0 +1,7 @@
+import { AxiosInstance } from 'axios';
+import { TapstackRecord, TapstackResponse } from '../types';
+export declare class RecordModule {
+    private client;
+    constructor(client: AxiosInstance);
+    query<T = TapstackRecord[]>(slug: string, variables: any): Promise<TapstackResponse<T>>;
+}

package/dist/db/src/modules/records.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecordModule = void 0;
+const request_1 = require("../request");
+class RecordModule {
+    constructor(client) {
+        this.client = client;
+    }
+    query(slug, variables) {
+        return (0, request_1.handleRequest)(this.client, { method: 'POST', url: `/${slug}`, data: variables });
+    }
+}
+exports.RecordModule = RecordModule;

package/dist/db/src/request.d.ts

@@ -0,0 +1,2 @@
+import { AxiosInstance, AxiosRequestConfig } from 'axios';
+export declare function handleRequest<T>(client: AxiosInstance, config: AxiosRequestConfig): Promise<T>;

package/dist/db/src/request.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequest = handleRequest;
+const axios_1 = __importDefault(require("axios"));
+async function handleRequest(client, config) {
+    try {
+        const response = await client.request(config);
+        return response.data;
+    }
+    catch (err) {
+        if (axios_1.default.isAxiosError(err)) {
+            const message = err.response?.data?.message || err.message;
+            throw new Error(message);
+        }
+        throw err;
+    }
+}

package/dist/db/src/types.d.ts

@@ -0,0 +1,19 @@
+export interface TapstackObject {
+    slug: string;
+    name: string;
+    [key: string]: any;
+}
+export interface TapstackField {
+    id: string;
+    name: string;
+    type: string;
+    [key: string]: any;
+}
+export type TapstackRecord = Record<string, any> & {
+    id?: string;
+};
+export interface TapstackResponse<T> {
+    data: T;
+}
+export type CreateObjectPayload = Partial<TapstackObject>;
+export type CreateFieldPayload = Partial<TapstackField>;

package/dist/db/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@tapstack/db",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "@tapstack/core": "^1.0.0"
+  }
+}

package/src/__tests__/client.test.ts

@@ -0,0 +1,84 @@
+import axios from 'axios';
+import { TapstackDBClient } from '../index';
+
+jest.mock('axios');
+
+const mockedCreate = axios.create as jest.Mock;
+
+describe('TapstackDBClient', () => {
+  const apiClient = {
+    get: jest.fn(),
+    post: jest.fn(),
+    put: jest.fn(),
+    delete: jest.fn(),
+  };
+
+  let client: TapstackDBClient;
+
+  beforeEach(() => {
+    mockedCreate.mockReturnValue(apiClient);
+    client = new TapstackDBClient({ baseURL: 'http://example.com', apiKey: 'token' });
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+
+  it('getObject calls axios.get with correct path', async () => {
+    await client.getObject('item');
+    expect(apiClient.get).toHaveBeenCalledWith('/system/item');
+  });
+
+  it('getAllObjects calls axios.get on /system', async () => {
+    await client.getAllObjects();
+    expect(apiClient.get).toHaveBeenCalledWith('/system');
+  });
+
+  it('createObject posts to /system', async () => {
+    const data = { name: 'test' };
+    await client.createObject(data);
+    expect(apiClient.post).toHaveBeenCalledWith('/system', data);
+  });
+
+  it('updateObject puts to correct path', async () => {
+    await client.updateObject('item', { a: 1 });
+    expect(apiClient.put).toHaveBeenCalledWith('/system/item', { a: 1 });
+  });
+
+  it('deleteObject deletes from correct path', async () => {
+    await client.deleteObject('item');
+    expect(apiClient.delete).toHaveBeenCalledWith('/system/item');
+  });
+
+  it('getFields calls axios.get with fields path', async () => {
+    await client.getFields('item');
+    expect(apiClient.get).toHaveBeenCalledWith('/system/item/fields');
+  });
+
+  it('getField calls axios.get with field id', async () => {
+    await client.getField('item', '1');
+    expect(apiClient.get).toHaveBeenCalledWith('/system/item/fields/1');
+  });
+
+  it('createField posts to fields path', async () => {
+    await client.createField('item', { name: 'field' });
+    expect(apiClient.post).toHaveBeenCalledWith('/system/item/fields', { name: 'field' });
+  });
+
+  it('updateField puts to specific field path', async () => {
+    await client.updateField('item', '1', { name: 'f' });
+    expect(apiClient.put).toHaveBeenCalledWith('/system/item/fields/1', { name: 'f' });
+  });
+
+  it('deleteField deletes the field path', async () => {
+    await client.deleteField('item', '1');
+    expect(apiClient.delete).toHaveBeenCalledWith('/system/item/fields/1');
+  });
+
+  it('query posts to slug', async () => {
+    const variables = { a: 1 };
+    await client.query('item', variables);
+    expect(apiClient.post).toHaveBeenCalledWith('/item', variables);
+  });
+});

package/src/index.ts

@@ -0,0 +1,70 @@
+export * from './types';
+export * from './modules/objects';
+export * from './modules/fields';
+export * from './modules/records';
+
+import { AxiosResponse } from 'axios';
+import { BaseClient, BaseClientConfig } from '@tapstack/core';
+import { ObjectModule } from './modules/objects';
+import { FieldModule } from './modules/fields';
+import { RecordModule } from './modules/records';
+import { CreateFieldPayload, CreateObjectPayload } from './types';
+
+export interface TapstackDBClientConfig extends BaseClientConfig {}
+
+export class TapstackDBClient extends BaseClient {
+  readonly objects: ObjectModule;
+  readonly fields: FieldModule;
+  readonly records: RecordModule;
+
+  constructor(config: TapstackDBClientConfig) {
+    super(config);
+    this.objects = new ObjectModule(this.client);
+    this.fields = new FieldModule(this.client);
+    this.records = new RecordModule(this.client);
+  }
+
+  async getObject(slug: string): Promise<AxiosResponse<any>> {
+    return this.client.get(`/system/${slug}`);
+  }
+
+  async getAllObjects(): Promise<AxiosResponse<any>> {
+    return this.client.get(`/system`);
+  }
+
+  async createObject(data: CreateObjectPayload): Promise<AxiosResponse<any>> {
+    return this.client.post(`/system`, data);
+  }
+
+  async updateObject(slug: string, data: Partial<CreateObjectPayload>): Promise<AxiosResponse<any>> {
+    return this.client.put(`/system/${slug}`, data);
+  }
+
+  async deleteObject(slug: string): Promise<AxiosResponse<any>> {
+    return this.client.delete(`/system/${slug}`);
+  }
+
+  async getFields(slug: string): Promise<AxiosResponse<any>> {
+    return this.client.get(`/system/${slug}/fields`);
+  }
+
+  async getField(slug: string, fieldID: string): Promise<AxiosResponse<any>> {
+    return this.client.get(`/system/${slug}/fields/${fieldID}`);
+  }
+
+  async createField(slug: string, data: CreateFieldPayload): Promise<AxiosResponse<any>> {
+    return this.client.post(`/system/${slug}/fields`, data);
+  }
+
+  async updateField(slug: string, fieldID: string, data: Partial<CreateFieldPayload>): Promise<AxiosResponse<any>> {
+    return this.client.put(`/system/${slug}/fields/${fieldID}`, data);
+  }
+
+  async deleteField(slug: string, fieldID: string): Promise<AxiosResponse<any>> {
+    return this.client.delete(`/system/${slug}/fields/${fieldID}`);
+  }
+
+  async query(slug: string, variables: any): Promise<AxiosResponse<any>> {
+    return this.client.post(`/${slug}`, variables);
+  }
+}

package/src/modules/fields.ts

@@ -0,0 +1,27 @@
+import { AxiosInstance } from 'axios';
+import { handleRequest } from '../request';
+import { TapstackField, TapstackResponse } from '../types';
+
+export class FieldModule {
+  constructor(private client: AxiosInstance) {}
+
+  list(slug: string): Promise<TapstackResponse<TapstackField[]>> {
+    return handleRequest(this.client, { method: 'GET', url: `/system/${slug}/fields` });
+  }
+
+  get(slug: string, fieldID: string): Promise<TapstackResponse<TapstackField>> {
+    return handleRequest(this.client, { method: 'GET', url: `/system/${slug}/fields/${fieldID}` });
+  }
+
+  create(slug: string, data: Partial<TapstackField>): Promise<TapstackResponse<TapstackField>> {
+    return handleRequest(this.client, { method: 'POST', url: `/system/${slug}/fields`, data });
+  }
+
+  update(slug: string, fieldID: string, data: Partial<TapstackField>): Promise<TapstackResponse<TapstackField>> {
+    return handleRequest(this.client, { method: 'PUT', url: `/system/${slug}/fields/${fieldID}`, data });
+  }
+
+  delete(slug: string, fieldID: string): Promise<TapstackResponse<void>> {
+    return handleRequest(this.client, { method: 'DELETE', url: `/system/${slug}/fields/${fieldID}` });
+  }
+}

package/src/modules/objects.ts

@@ -0,0 +1,27 @@
+import { AxiosInstance } from 'axios';
+import { handleRequest } from '../request';
+import { TapstackObject, TapstackResponse } from '../types';
+
+export class ObjectModule {
+  constructor(private client: AxiosInstance) {}
+
+  get(slug: string): Promise<TapstackResponse<TapstackObject>> {
+    return handleRequest(this.client, { method: 'GET', url: `/system/${slug}` });
+  }
+
+  list(): Promise<TapstackResponse<TapstackObject[]>> {
+    return handleRequest(this.client, { method: 'GET', url: `/system` });
+  }
+
+  create(data: Partial<TapstackObject>): Promise<TapstackResponse<TapstackObject>> {
+    return handleRequest(this.client, { method: 'POST', url: `/system`, data });
+  }
+
+  update(slug: string, data: Partial<TapstackObject>): Promise<TapstackResponse<TapstackObject>> {
+    return handleRequest(this.client, { method: 'PUT', url: `/system/${slug}`, data });
+  }
+
+  delete(slug: string): Promise<TapstackResponse<void>> {
+    return handleRequest(this.client, { method: 'DELETE', url: `/system/${slug}` });
+  }
+}

package/src/modules/records.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from 'axios';
+import { handleRequest } from '../request';
+import { TapstackRecord, TapstackResponse } from '../types';
+
+export class RecordModule {
+  constructor(private client: AxiosInstance) {}
+
+  query<T = TapstackRecord[]>(slug: string, variables: any): Promise<TapstackResponse<T>> {
+    return handleRequest(this.client, { method: 'POST', url: `/${slug}`, data: variables });
+  }
+}

package/src/request.ts

@@ -0,0 +1,14 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+
+export async function handleRequest<T>(client: AxiosInstance, config: AxiosRequestConfig): Promise<T> {
+  try {
+    const response = await client.request<T>(config);
+    return response.data;
+  } catch (err) {
+    if (axios.isAxiosError(err)) {
+      const message = (err.response?.data as any)?.message || err.message;
+      throw new Error(message);
+    }
+    throw err;
+  }
+}

package/src/types.ts

@@ -0,0 +1,21 @@
+export interface TapstackObject {
+  slug: string;
+  name: string;
+  [key: string]: any;
+}
+
+export interface TapstackField {
+  id: string;
+  name: string;
+  type: string;
+  [key: string]: any;
+}
+
+export type TapstackRecord = Record<string, any> & { id?: string };
+
+export interface TapstackResponse<T> {
+  data: T;
+}
+
+export type CreateObjectPayload = Partial<TapstackObject>;
+export type CreateFieldPayload = Partial<TapstackField>;

package/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}