@tapstack/db 1.0.6 → 3.0.0

package/dist/modules/objects.js

@@ -1,25 +1,47 @@
 "use strict";
+/**
+ * Objects Module
+ * CRUD operations for Tapstack objects (data models)
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectModule = void 0;
-const request_1 = require("../request");
 class ObjectModule {
-    constructor(client) {
-        this.client = client;
+    constructor(adapter) {
+        this.adapter = adapter;
     }
-    get(slug) {
-        return (0, request_1.handleRequest)(this.client, { method: 'GET', url: `/system/${slug}` });
+    /**
+     * List all objects in the workspace
+     */
+    async list() {
+        return this.adapter.request('GET', 'schema/objects');
     }
-    list() {
-        return (0, request_1.handleRequest)(this.client, { method: 'GET', url: `/system` });
+    /**
+     * Get a single object by slug
+     */
+    async get(slug) {
+        return this.adapter.request('GET', `schema/objects/${slug}`);
     }
-    create(data) {
-        return (0, request_1.handleRequest)(this.client, { method: 'POST', url: `/system`, data });
+    /**
+     * Create a new object
+     */
+    async create(data) {
+        return this.adapter.request('POST', 'schema/objects', {
+            body: data,
+        });
     }
-    update(slug, data) {
-        return (0, request_1.handleRequest)(this.client, { method: 'PUT', url: `/system/${slug}`, data });
+    /**
+     * Update an existing object
+     */
+    async update(slug, data) {
+        return this.adapter.request('PATCH', `schema/objects/${slug}`, {
+            body: data,
+        });
     }
-    delete(slug) {
-        return (0, request_1.handleRequest)(this.client, { method: 'DELETE', url: `/system/${slug}` });
+    /**
+     * Delete an object (soft delete by default)
+     */
+    async delete(slug, soft = true) {
+        return this.adapter.request('DELETE', `schema/objects/${slug}`, { params: { soft: String(soft) } });
     }
 }
 exports.ObjectModule = ObjectModule;

package/dist/modules/organizations.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Organizations Module
+ * CRUD operations for Tapstack organizations
+ */
+import { IInstanceAdapter } from '../adapters/types';
+import { TapstackOrganization, CreateOrganizationPayload, UpdateOrganizationPayload, OrganizationListResponse, OrganizationMember, TapstackWorkspace, WorkspaceListResponse } from '../types';
+export declare class OrganizationModule {
+    private adapter;
+    constructor(adapter: IInstanceAdapter);
+    /**
+     * List all organizations the user belongs to
+     */
+    list(): Promise<OrganizationListResponse>;
+    /**
+     * Get a single organization by ID
+     */
+    get(orgId: string): Promise<TapstackOrganization>;
+    /**
+     * Create a new organization
+     */
+    create(data: CreateOrganizationPayload): Promise<TapstackOrganization>;
+    /**
+     * Update an existing organization
+     */
+    update(orgId: string, data: UpdateOrganizationPayload): Promise<TapstackOrganization>;
+    /**
+     * Delete an organization
+     */
+    delete(orgId: string): Promise<{
+        deleted: boolean;
+    }>;
+    /**
+     * List workspaces in an organization
+     */
+    listWorkspaces(orgId: string): Promise<WorkspaceListResponse>;
+    /**
+     * Create a workspace in an organization
+     */
+    createWorkspace(orgId: string, data: {
+        name: string;
+        slug?: string;
+        description?: string;
+    }): Promise<TapstackWorkspace>;
+    /**
+     * List members of an organization
+     */
+    listMembers(orgId: string): Promise<{
+        members: OrganizationMember[];
+    }>;
+    /**
+     * Add a member to an organization
+     */
+    addMember(orgId: string, data: {
+        email: string;
+        role?: string;
+    }): Promise<OrganizationMember>;
+    /**
+     * Update a member's role
+     */
+    updateMember(orgId: string, memberId: string, data: {
+        role: string;
+    }): Promise<OrganizationMember>;
+    /**
+     * Remove a member from an organization
+     */
+    removeMember(orgId: string, memberId: string): Promise<{
+        removed: boolean;
+    }>;
+}

package/dist/modules/organizations.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Organizations Module
+ * CRUD operations for Tapstack organizations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrganizationModule = void 0;
+class OrganizationModule {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * List all organizations the user belongs to
+     */
+    async list() {
+        return this.adapter.request('GET', 'organizations');
+    }
+    /**
+     * Get a single organization by ID
+     */
+    async get(orgId) {
+        return this.adapter.request('GET', `organizations/${orgId}`);
+    }
+    /**
+     * Create a new organization
+     */
+    async create(data) {
+        return this.adapter.request('POST', 'organizations', {
+            body: data,
+        });
+    }
+    /**
+     * Update an existing organization
+     */
+    async update(orgId, data) {
+        return this.adapter.request('PATCH', `organizations/${orgId}`, {
+            body: data,
+        });
+    }
+    /**
+     * Delete an organization
+     */
+    async delete(orgId) {
+        return this.adapter.request('DELETE', `organizations/${orgId}`);
+    }
+    /**
+     * List workspaces in an organization
+     */
+    async listWorkspaces(orgId) {
+        return this.adapter.request('GET', `organizations/${orgId}/workspaces`);
+    }
+    /**
+     * Create a workspace in an organization
+     */
+    async createWorkspace(orgId, data) {
+        return this.adapter.request('POST', `organizations/${orgId}/workspaces`, { body: data });
+    }
+    /**
+     * List members of an organization
+     */
+    async listMembers(orgId) {
+        return this.adapter.request('GET', `organizations/${orgId}/members`);
+    }
+    /**
+     * Add a member to an organization
+     */
+    async addMember(orgId, data) {
+        return this.adapter.request('POST', `organizations/${orgId}/members`, { body: data });
+    }
+    /**
+     * Update a member's role
+     */
+    async updateMember(orgId, memberId, data) {
+        return this.adapter.request('PATCH', `organizations/${orgId}/members/${memberId}`, { body: data });
+    }
+    /**
+     * Remove a member from an organization
+     */
+    async removeMember(orgId, memberId) {
+        return this.adapter.request('DELETE', `organizations/${orgId}/members/${memberId}`);
+    }
+}
+exports.OrganizationModule = OrganizationModule;

package/dist/modules/records.d.ts

@@ -1,7 +1,49 @@
-import { AxiosInstance } from 'axios';
-import { TapstackRecord, TapstackResponse } from '../types';
+/**
+ * Records Module
+ * CRUD operations for Tapstack records (data entries)
+ */
+import { IInstanceAdapter } from '../adapters/types';
+import { TapstackRecord, CreateRecordPayload, UpdateRecordPayload, RecordQueryOptions, RecordListResponse } from '../types';
 export declare class RecordModule {
-    private client;
-    constructor(client: AxiosInstance);
-    query<T = TapstackRecord[]>(slug: string, variables: any): Promise<TapstackResponse<T>>;
+    private adapter;
+    constructor(adapter: IInstanceAdapter);
+    /**
+     * List records for an object with pagination and filtering
+     */
+    list(objectSlug: string, options?: RecordQueryOptions): Promise<RecordListResponse>;
+    /**
+     * Get a single record by ID
+     */
+    get(objectSlug: string, recordId: string): Promise<TapstackRecord>;
+    /**
+     * Create a new record
+     */
+    create(objectSlug: string, data: CreateRecordPayload): Promise<TapstackRecord>;
+    /**
+     * Update an existing record
+     */
+    update(objectSlug: string, recordId: string, data: UpdateRecordPayload): Promise<TapstackRecord>;
+    /**
+     * Delete a record (soft delete by default)
+     */
+    delete(objectSlug: string, recordId: string, soft?: boolean): Promise<{
+        deleted: boolean;
+    }>;
+    /**
+     * Bulk create records
+     */
+    bulkCreate(objectSlug: string, records: CreateRecordPayload[]): Promise<{
+        records: TapstackRecord[];
+        count: number;
+    }>;
+    /**
+     * Bulk delete records (soft delete by default)
+     */
+    bulkDelete(objectSlug: string, recordIds: string[], soft?: boolean): Promise<{
+        deleted: number;
+    }>;
+    /**
+     * Query records with advanced filtering (legacy method for backwards compatibility)
+     */
+    query<T = TapstackRecord[]>(objectSlug: string, variables: Record<string, unknown>): Promise<T>;
 }

package/dist/modules/records.js

@@ -1,13 +1,78 @@
 "use strict";
+/**
+ * Records Module
+ * CRUD operations for Tapstack records (data entries)
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecordModule = void 0;
-const request_1 = require("../request");
 class RecordModule {
-    constructor(client) {
-        this.client = client;
+    constructor(adapter) {
+        this.adapter = adapter;
     }
-    query(slug, variables) {
-        return (0, request_1.handleRequest)(this.client, { method: 'POST', url: `/${slug}`, data: variables });
+    /**
+     * List records for an object with pagination and filtering
+     */
+    async list(objectSlug, options) {
+        const params = {};
+        if (options?.page)
+            params.page = String(options.page);
+        if (options?.pageSize)
+            params.pageSize = String(options.pageSize);
+        if (options?.sortBy)
+            params.sortBy = options.sortBy;
+        if (options?.sortOrder)
+            params.sortOrder = options.sortOrder;
+        if (options?.filters)
+            params.filters = JSON.stringify(options.filters);
+        return this.adapter.request('GET', `records/${objectSlug}`, {
+            params,
+        });
+    }
+    /**
+     * Get a single record by ID
+     */
+    async get(objectSlug, recordId) {
+        return this.adapter.request('GET', `records/${objectSlug}/${recordId}`);
+    }
+    /**
+     * Create a new record
+     */
+    async create(objectSlug, data) {
+        return this.adapter.request('POST', `records/${objectSlug}`, {
+            body: data,
+        });
+    }
+    /**
+     * Update an existing record
+     */
+    async update(objectSlug, recordId, data) {
+        return this.adapter.request('PATCH', `records/${objectSlug}/${recordId}`, { body: data });
+    }
+    /**
+     * Delete a record (soft delete by default)
+     */
+    async delete(objectSlug, recordId, soft = true) {
+        return this.adapter.request('DELETE', `records/${objectSlug}/${recordId}`, { params: { soft: String(soft) } });
+    }
+    /**
+     * Bulk create records
+     */
+    async bulkCreate(objectSlug, records) {
+        return this.adapter.request('POST', `records/${objectSlug}/bulk`, { body: { records } });
+    }
+    /**
+     * Bulk delete records (soft delete by default)
+     */
+    async bulkDelete(objectSlug, recordIds, soft = true) {
+        return this.adapter.request('POST', `records/${objectSlug}/bulk/delete`, { body: { recordIds, soft } });
+    }
+    /**
+     * Query records with advanced filtering (legacy method for backwards compatibility)
+     */
+    async query(objectSlug, variables) {
+        return this.adapter.request('POST', `records/${objectSlug}/query`, {
+            body: variables,
+        });
     }
 }
 exports.RecordModule = RecordModule;

package/dist/modules/workspaces.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Workspaces Module
+ * CRUD operations for Tapstack workspaces
+ */
+import { IInstanceAdapter } from '../adapters/types';
+import { TapstackWorkspace, CreateWorkspacePayload, UpdateWorkspacePayload, WorkspaceListResponse } from '../types';
+export declare class WorkspaceModule {
+    private adapter;
+    constructor(adapter: IInstanceAdapter);
+    /**
+     * List all workspaces the user has access to
+     */
+    list(): Promise<WorkspaceListResponse>;
+    /**
+     * Get a single workspace by ID
+     */
+    get(workspaceId: string): Promise<TapstackWorkspace>;
+    /**
+     * Create a new workspace (within an organization)
+     */
+    create(orgId: string, data: CreateWorkspacePayload): Promise<TapstackWorkspace>;
+    /**
+     * Update an existing workspace
+     */
+    update(orgId: string, workspaceId: string, data: UpdateWorkspacePayload): Promise<TapstackWorkspace>;
+    /**
+     * Delete a workspace
+     */
+    delete(orgId: string, workspaceId: string): Promise<{
+        deleted: boolean;
+    }>;
+    /**
+     * Get workspace statistics
+     */
+    getStats(workspaceId: string): Promise<{
+        objectCount: number;
+        recordCount: number;
+        storageUsed: number;
+    }>;
+    /**
+     * Resolve a workspace by slug (for routing)
+     */
+    resolveBySlug(orgSlug: string, workspaceSlug: string): Promise<TapstackWorkspace>;
+}

package/dist/modules/workspaces.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Workspaces Module
+ * CRUD operations for Tapstack workspaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceModule = void 0;
+class WorkspaceModule {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * List all workspaces the user has access to
+     */
+    async list() {
+        return this.adapter.request('GET', 'workspaces');
+    }
+    /**
+     * Get a single workspace by ID
+     */
+    async get(workspaceId) {
+        return this.adapter.request('GET', `workspaces/${workspaceId}`);
+    }
+    /**
+     * Create a new workspace (within an organization)
+     */
+    async create(orgId, data) {
+        return this.adapter.request('POST', `workspaces/org/${orgId}`, {
+            body: data,
+        });
+    }
+    /**
+     * Update an existing workspace
+     */
+    async update(orgId, workspaceId, data) {
+        return this.adapter.request('PATCH', `workspaces/org/${orgId}/${workspaceId}`, { body: data });
+    }
+    /**
+     * Delete a workspace
+     */
+    async delete(orgId, workspaceId) {
+        return this.adapter.request('DELETE', `workspaces/org/${orgId}/${workspaceId}`);
+    }
+    /**
+     * Get workspace statistics
+     */
+    async getStats(workspaceId) {
+        return this.adapter.request('GET', `workspaces/${workspaceId}/stats`);
+    }
+    /**
+     * Resolve a workspace by slug (for routing)
+     */
+    async resolveBySlug(orgSlug, workspaceSlug) {
+        return this.adapter.request('GET', `resolve-workspace/${orgSlug}/${workspaceSlug}`);
+    }
+}
+exports.WorkspaceModule = WorkspaceModule;

package/dist/types.d.ts

@@ -1,19 +1,168 @@
+/**
+ * Core Types for @tapstack/db
+ */
+export * from './adapters/types';
 export interface TapstackObject {
+    id: string;
+    singleName: string;
+    pluralName: string;
     slug: string;
-    name: string;
-    [key: string]: any;
+    icon: string;
+    isSystemObject: boolean;
+    use?: string | null;
+    parentId?: string | null;
+    workspaceId?: string | null;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt?: number | null;
+    fields?: TapstackField[];
 }
+export type CreateObjectPayload = {
+    singleName: string;
+    pluralName: string;
+    slug?: string;
+    icon?: string;
+    use?: string;
+    parentId?: string;
+};
+export type UpdateObjectPayload = Partial<CreateObjectPayload>;
+export type FieldType = 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'json' | 'select' | 'single_select' | 'multi_select' | 'checkbox' | 'radio' | 'relation' | 'input' | 'textarea' | 'autoincrement' | 'htmlBox' | 'email' | 'phone' | 'url' | 'currency' | 'rating' | 'fullName' | 'address' | 'array' | 'ai' | 'person' | 'files';
 export interface TapstackField {
+    id: string;
+    label: string;
+    value: string;
+    type: FieldType;
+    data?: Record<string, unknown>;
+    systemData?: Record<string, unknown>;
+    objectId: string;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt?: number | null;
+}
+export type CreateFieldPayload = {
+    label: string;
+    value: string;
+    type: FieldType;
+    data?: Record<string, unknown>;
+};
+export type UpdateFieldPayload = Partial<Omit<CreateFieldPayload, 'value'>>;
+export type RecordStatus = 'draft' | 'published' | 'deleted';
+export interface TapstackRecord {
+    id: string;
+    objectId: string;
+    workspaceId?: string;
+    data: Record<string, unknown>;
+    status: RecordStatus;
+    version: number;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt?: number | null;
+}
+export type CreateRecordPayload = {
+    data: Record<string, unknown>;
+    status?: RecordStatus;
+};
+export type UpdateRecordPayload = {
+    data?: Record<string, unknown>;
+    status?: RecordStatus;
+};
+export interface RecordQueryOptions {
+    page?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+    filters?: Record<string, unknown>;
+}
+export interface RecordListResponse {
+    items: TapstackRecord[];
+    total: number;
+    page: number;
+    pageSize: number;
+    totalPages: number;
+}
+export interface TapstackOrganization {
     id: string;
     name: string;
-    type: string;
-    [key: string]: any;
+    slug: string;
+    ownerId: string;
+    stripeCustomerId?: string | null;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt?: number | null;
 }
-export type TapstackRecord = Record<string, any> & {
-    id?: string;
+export type CreateOrganizationPayload = {
+    name: string;
+    slug?: string;
 };
-export interface TapstackResponse<T> {
-    data: T;
+export type UpdateOrganizationPayload = Partial<CreateOrganizationPayload>;
+export interface OrganizationMember {
+    id: string;
+    organizationId: string;
+    userId: string;
+    role: string;
+    createdAt: number;
+    updatedAt: number;
 }
-export type CreateObjectPayload = Partial<TapstackObject>;
-export type CreateFieldPayload = Partial<TapstackField>;
+export interface TapstackWorkspace {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string | null;
+    organizationId: string;
+    createdAt: number;
+    updatedAt: number;
+    deletedAt?: number | null;
+}
+export type CreateWorkspacePayload = {
+    name: string;
+    slug?: string;
+    description?: string;
+};
+export type UpdateWorkspacePayload = Partial<CreateWorkspacePayload>;
+export interface TapstackFile {
+    id: string;
+    name: string;
+    path: string;
+    mimeType: string;
+    size: number;
+    url?: string;
+    folderId?: string | null;
+    workspaceId: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface TapstackFolder {
+    id: string;
+    name: string;
+    parentId?: string | null;
+    workspaceId: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface FileUploadOptions {
+    folderId?: string;
+    folder?: string;
+}
+export interface FileListResponse {
+    files: TapstackFile[];
+    total: number;
+}
+export interface FolderListResponse {
+    folders: TapstackFolder[];
+}
+export interface ObjectListResponse {
+    objects: TapstackObject[];
+}
+export interface FieldListResponse {
+    fields: TapstackField[];
+}
+export interface OrganizationListResponse {
+    organizations: TapstackOrganization[];
+}
+export interface WorkspaceListResponse {
+    workspaces: TapstackWorkspace[];
+}
+/** @deprecated Use TapstackObject instead */
+export type TapstackResponse<T> = {
+    data: T;
+};

package/dist/types.js

@@ -1,2 +1,21 @@
 "use strict";
+/**
+ * Core Types for @tapstack/db
+ */
+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 });
+// Re-export adapter types
+__exportStar(require("./adapters/types"), exports);

package/package.json

@@ -1,17 +1,26 @@
 {
   "name": "@tapstack/db",
-  "version": "1.0.6",
+  "version": "3.0.0",
+  "description": "Tapstack Database Client - Official SDK for the Tapstack API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "jest"
   },
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "axios": "^1.6.0",
-    "@tapstack/core": "^1.0.6"
-  }
-}
+  "peerDependencies": {
+    "typescript": ">=4.7"
+  },
+  "keywords": [
+    "tapstack",
+    "database",
+    "client",
+    "api",
+    "sdk"
+  ],
+  "license": "MIT"
+}