@tapstack/db 1.0.7 → 3.0.0

package/src/modules/organizations.ts

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

package/src/modules/records.ts

@@ -1,11 +1,124 @@
-import { AxiosInstance } from 'axios';
-import { handleRequest } from '../request';
-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 class RecordModule {
-  constructor(private client: AxiosInstance) {}
+  constructor(private adapter: IInstanceAdapter) { }
+
+  /**
+   * List records for an object with pagination and filtering
+   */
+  async list(objectSlug: string, options?: RecordQueryOptions): Promise<RecordListResponse> {
+    const params: Record<string, string> = {};
+
+    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<RecordListResponse>('GET', `records/${objectSlug}`, {
+      params,
+    });
+  }
+
+  /**
+   * Get a single record by ID
+   */
+  async get(objectSlug: string, recordId: string): Promise<TapstackRecord> {
+    return this.adapter.request<TapstackRecord>(
+      'GET',
+      `records/${objectSlug}/${recordId}`
+    );
+  }
+
+  /**
+   * Create a new record
+   */
+  async create(objectSlug: string, data: CreateRecordPayload): Promise<TapstackRecord> {
+    return this.adapter.request<TapstackRecord>('POST', `records/${objectSlug}`, {
+      body: data,
+    });
+  }
+
+  /**
+   * Update an existing record
+   */
+  async update(
+    objectSlug: string,
+    recordId: string,
+    data: UpdateRecordPayload
+  ): Promise<TapstackRecord> {
+    return this.adapter.request<TapstackRecord>(
+      'PATCH',
+      `records/${objectSlug}/${recordId}`,
+      { body: data }
+    );
+  }
+
+  /**
+   * Delete a record (soft delete by default)
+   */
+  async delete(
+    objectSlug: string,
+    recordId: string,
+    soft = true
+  ): Promise<{ deleted: boolean }> {
+    return this.adapter.request<{ deleted: boolean }>(
+      'DELETE',
+      `records/${objectSlug}/${recordId}`,
+      { params: { soft: String(soft) } }
+    );
+  }
+
+  /**
+   * Bulk create records
+   */
+  async bulkCreate(
+    objectSlug: string,
+    records: CreateRecordPayload[]
+  ): Promise<{ records: TapstackRecord[]; count: number }> {
+    return this.adapter.request<{ records: TapstackRecord[]; count: number }>(
+      'POST',
+      `records/${objectSlug}/bulk`,
+      { body: { records } }
+    );
+  }
+
+  /**
+   * Bulk delete records (soft delete by default)
+   */
+  async bulkDelete(
+    objectSlug: string,
+    recordIds: string[],
+    soft = true
+  ): Promise<{ deleted: number }> {
+    return this.adapter.request<{ deleted: number }>(
+      'POST',
+      `records/${objectSlug}/bulk/delete`,
+      { body: { recordIds, soft } }
+    );
+  }
 
-  query<T = TapstackRecord[]>(slug: string, variables: any): Promise<TapstackResponse<T>> {
-    return handleRequest(this.client, { method: 'POST', url: `/${slug}`, data: variables });
+  /**
+   * Query records with advanced filtering (legacy method for backwards compatibility)
+   */
+  async query<T = TapstackRecord[]>(
+    objectSlug: string,
+    variables: Record<string, unknown>
+  ): Promise<T> {
+    return this.adapter.request<T>('POST', `records/${objectSlug}/query`, {
+      body: variables,
+    });
   }
 }

package/src/modules/workspaces.ts

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

package/src/types.ts

@@ -1,21 +1,241 @@
+/**
+ * Core Types for @tapstack/db
+ */
+
+// Re-export adapter types
+export * from './adapters/types';
+
+// ==================== Objects ====================
+
 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>;
+
+// ==================== Fields ====================
+
+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'>>;
+
+// ==================== Records ====================
+
+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;
+}
+
+// ==================== Organizations ====================
+
+export interface TapstackOrganization {
+  id: string;
+  name: string;
+  slug: string;
+  ownerId: string;
+  stripeCustomerId?: string | null;
+  createdAt: number;
+  updatedAt: number;
+  deletedAt?: number | null;
+}
+
+export type CreateOrganizationPayload = {
+  name: string;
+  slug?: string;
+};
+
+export type UpdateOrganizationPayload = Partial<CreateOrganizationPayload>;
+
+export interface OrganizationMember {
+  id: string;
+  organizationId: string;
+  userId: string;
+  role: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+// ==================== Workspaces ====================
+
+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>;
+
+// ==================== Files ====================
+
+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;
-  type: string;
-  [key: string]: any;
+  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[];
+}
+
+// ==================== API Response Types ====================
+
+export interface ObjectListResponse {
+  objects: TapstackObject[];
 }
 
-export type TapstackRecord = Record<string, any> & { id?: string };
+export interface FieldListResponse {
+  fields: TapstackField[];
+}
+
+export interface OrganizationListResponse {
+  organizations: TapstackOrganization[];
+}
 
-export interface TapstackResponse<T> {
-  data: T;
+export interface WorkspaceListResponse {
+  workspaces: TapstackWorkspace[];
 }
 
-export type CreateObjectPayload = Partial<TapstackObject>;
-export type CreateFieldPayload = Partial<TapstackField>;
+// ==================== Legacy Types (for backwards compatibility) ====================
+
+/** @deprecated Use TapstackObject instead */
+export type TapstackResponse<T> = { data: T };

package/dist/request.d.ts

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

package/dist/request.js

@@ -1,20 +0,0 @@
-"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/src/request.ts

@@ -1,14 +0,0 @@
-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;
-  }
-}