@tapstack/db 1.0.7 → 3.0.0

package/src/modules/automations.ts

@@ -0,0 +1,157 @@
+/**
+ * Automations Module
+ * CRUD operations for workflow automations
+ */
+
+import { IInstanceAdapter } from '../adapters/types';
+
+export interface TriggerCondition {
+  field: string;
+  operator: string;
+  value: unknown;
+}
+
+export interface FieldMapping {
+  type: 'static' | 'trigger_field';
+  value: string;
+}
+
+export interface AutomationAction {
+  id: string;
+  type: 'create_record' | 'update_record' | 'delete_record' | 'webhook';
+  config: {
+    targetObjectId?: string;
+    fieldMappings?: Record<string, FieldMapping>;
+    url?: string;
+    method?: 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    body?: string;
+  };
+}
+
+export interface Automation {
+  id: string;
+  name: string;
+  description?: string;
+  workspaceId: string;
+  triggerObjectId: string;
+  triggerType: 'record.created' | 'record.updated' | 'record.deleted';
+  triggerConditions: TriggerCondition[];
+  actions: AutomationAction[];
+  isEnabled: boolean;
+  lastRunAt?: number;
+  runCount: number;
+  createdAt: number;
+  updatedAt: number;
+  deletedAt?: number;
+  triggerObject?: {
+    id: string;
+    singleName: string;
+    pluralName: string;
+    slug: string;
+    icon?: string;
+  };
+}
+
+export interface CreateAutomationPayload {
+  name: string;
+  description?: string;
+  triggerObjectId: string;
+  triggerType: 'record.created' | 'record.updated' | 'record.deleted';
+  triggerConditions?: TriggerCondition[];
+  actions: Omit<AutomationAction, 'id'>[];
+}
+
+export interface UpdateAutomationPayload {
+  name?: string;
+  description?: string;
+  triggerConditions?: TriggerCondition[];
+  actions?: AutomationAction[];
+  isEnabled?: boolean;
+}
+
+export interface ExecuteAutomationResult {
+  success: boolean;
+  results: Array<{
+    actionId: string;
+    success: boolean;
+    error?: string;
+  }>;
+  message: string;
+}
+
+export class AutomationModule {
+  constructor(private adapter: IInstanceAdapter) { }
+
+  /**
+   * List all automations for the current workspace
+   */
+  async list(): Promise<{ automations: Automation[] }> {
+    return this.adapter.request<{ automations: Automation[] }>(
+      'GET',
+      'automations'
+    );
+  }
+
+  /**
+   * Get a single automation by ID
+   */
+  async get(id: string): Promise<Automation> {
+    return this.adapter.request<Automation>('GET', `automations/${id}`);
+  }
+
+  /**
+   * Create a new automation
+   */
+  async create(data: CreateAutomationPayload): Promise<Automation> {
+    return this.adapter.request<Automation>('POST', 'automations', {
+      body: data,
+    });
+  }
+
+  /**
+   * Update an existing automation
+   */
+  async update(id: string, data: UpdateAutomationPayload): Promise<Automation> {
+    return this.adapter.request<Automation>('PUT', `automations/${id}`, {
+      body: data,
+    });
+  }
+
+  /**
+   * Delete an automation
+   */
+  async delete(id: string, soft = true): Promise<{ deleted: boolean }> {
+    return this.adapter.request<{ deleted: boolean }>(
+      'DELETE',
+      `automations/${id}`,
+      { params: { soft: String(soft) } }
+    );
+  }
+
+  /**
+   * Toggle automation enabled/disabled
+   */
+  async toggle(id: string): Promise<Automation> {
+    return this.adapter.request<Automation>('POST', `automations/${id}/toggle`);
+  }
+
+  /**
+   * Execute an automation manually (for testing)
+   */
+  async execute(
+    id: string,
+    testData?: Record<string, unknown>
+  ): Promise<ExecuteAutomationResult> {
+    return this.adapter.request<ExecuteAutomationResult>(
+      'POST',
+      `automations/${id}/execute`,
+      { body: testData }
+    );
+  }
+}
+
+
+
+
+

package/src/modules/conversations.ts

@@ -0,0 +1,134 @@
+/**
+ * Conversations Module
+ * AI chat conversation management
+ */
+
+import { IInstanceAdapter } from '../adapters/types';
+
+export interface ToolCall {
+  name: string;
+  arguments?: Record<string, unknown>;
+  result?: unknown;
+  error?: string;
+}
+
+export interface Message {
+  id: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  toolCalls?: ToolCall[];
+  createdAt: number;
+}
+
+export interface Conversation {
+  id: string;
+  workspaceId: string;
+  userId?: string;
+  title: string;
+  lastMessage?: string;
+  messageCount: number;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface ConversationWithMessages extends Conversation {
+  messages: Message[];
+}
+
+export interface CreateConversationPayload {
+  title?: string;
+}
+
+export interface AddMessagePayload {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  toolCalls?: ToolCall[];
+}
+
+export interface ConversationListResponse {
+  conversations: Conversation[];
+  total: number;
+}
+
+export class ConversationModule {
+  constructor(private adapter: IInstanceAdapter) { }
+
+  /**
+   * List conversations for the current user/workspace
+   */
+  async list(options?: {
+    limit?: number;
+    offset?: number;
+  }): Promise<ConversationListResponse> {
+    const params: Record<string, string> = {};
+    if (options?.limit) params.limit = String(options.limit);
+    if (options?.offset) params.offset = String(options.offset);
+
+    return this.adapter.request<ConversationListResponse>(
+      'GET',
+      'conversations',
+      { params }
+    );
+  }
+
+  /**
+   * Get a single conversation with messages
+   */
+  async get(id: string): Promise<ConversationWithMessages> {
+    return this.adapter.request<ConversationWithMessages>(
+      'GET',
+      `conversations/${id}`
+    );
+  }
+
+  /**
+   * Create a new conversation
+   */
+  async create(data?: CreateConversationPayload): Promise<{ conversation: ConversationWithMessages }> {
+    return this.adapter.request<{ conversation: ConversationWithMessages }>(
+      'POST',
+      'conversations',
+      { body: data || {} }
+    );
+  }
+
+  /**
+   * Update a conversation (title)
+   */
+  async update(id: string, title: string): Promise<{ conversation: Conversation }> {
+    return this.adapter.request<{ conversation: Conversation }>(
+      'PATCH',
+      `conversations/${id}`,
+      { body: { title } }
+    );
+  }
+
+  /**
+   * Delete a conversation
+   */
+  async delete(id: string): Promise<{ deleted: boolean }> {
+    return this.adapter.request<{ deleted: boolean }>(
+      'DELETE',
+      `conversations/${id}`
+    );
+  }
+
+  /**
+   * Add a message to a conversation
+   */
+  async addMessage(
+    conversationId: string,
+    message: AddMessagePayload
+  ): Promise<{ message: Message }> {
+    return this.adapter.request<{ message: Message }>(
+      'POST',
+      `conversations/${conversationId}/messages`,
+      { body: message }
+    );
+  }
+}
+
+
+
+
+

package/src/modules/fields.ts

@@ -1,27 +1,77 @@
-import { AxiosInstance } from 'axios';
-import { handleRequest } from '../request';
-import { TapstackField, TapstackResponse } from '../types';
+/**
+ * Fields Module
+ * CRUD operations for Tapstack fields (object schema)
+ */
+
+import { IInstanceAdapter } from '../adapters/types';
+import {
+  TapstackField,
+  CreateFieldPayload,
+  UpdateFieldPayload,
+  FieldListResponse,
+} from '../types';
 
 export class FieldModule {
-  constructor(private client: AxiosInstance) {}
+  constructor(private adapter: IInstanceAdapter) { }
 
-  list(slug: string): Promise<TapstackResponse<TapstackField[]>> {
-    return handleRequest(this.client, { method: 'GET', url: `/system/${slug}/fields` });
+  /**
+   * List all fields for an object
+   */
+  async list(objectSlug: string): Promise<FieldListResponse> {
+    return this.adapter.request<FieldListResponse>(
+      'GET',
+      `schema/objects/${objectSlug}/fields`
+    );
   }
 
-  get(slug: string, fieldID: string): Promise<TapstackResponse<TapstackField>> {
-    return handleRequest(this.client, { method: 'GET', url: `/system/${slug}/fields/${fieldID}` });
+  /**
+   * Get a single field by ID
+   */
+  async get(objectSlug: string, fieldId: string): Promise<TapstackField> {
+    return this.adapter.request<TapstackField>(
+      'GET',
+      `schema/objects/${objectSlug}/fields/${fieldId}`
+    );
   }
 
-  create(slug: string, data: Partial<TapstackField>): Promise<TapstackResponse<TapstackField>> {
-    return handleRequest(this.client, { method: 'POST', url: `/system/${slug}/fields`, data });
+  /**
+   * Create a new field
+   */
+  async create(objectSlug: string, data: CreateFieldPayload): Promise<TapstackField> {
+    return this.adapter.request<TapstackField>(
+      'POST',
+      `schema/objects/${objectSlug}/fields`,
+      { body: data }
+    );
   }
 
-  update(slug: string, fieldID: string, data: Partial<TapstackField>): Promise<TapstackResponse<TapstackField>> {
-    return handleRequest(this.client, { method: 'PUT', url: `/system/${slug}/fields/${fieldID}`, data });
+  /**
+   * Update an existing field
+   */
+  async update(
+    objectSlug: string,
+    fieldId: string,
+    data: UpdateFieldPayload
+  ): Promise<TapstackField> {
+    return this.adapter.request<TapstackField>(
+      'PATCH',
+      `schema/objects/${objectSlug}/fields/${fieldId}`,
+      { body: data }
+    );
   }
 
-  delete(slug: string, fieldID: string): Promise<TapstackResponse<void>> {
-    return handleRequest(this.client, { method: 'DELETE', url: `/system/${slug}/fields/${fieldID}` });
+  /**
+   * Delete a field (soft delete by default)
+   */
+  async delete(
+    objectSlug: string,
+    fieldId: string,
+    soft = true
+  ): Promise<{ deleted: boolean }> {
+    return this.adapter.request<{ deleted: boolean }>(
+      'DELETE',
+      `schema/objects/${objectSlug}/fields/${fieldId}`,
+      { params: { soft: String(soft) } }
+    );
   }
 }

package/src/modules/files.ts

@@ -0,0 +1,144 @@
+/**
+ * Files Module
+ * File and folder operations using Supabase Storage
+ */
+
+import { IInstanceAdapter } from '../adapters/types';
+import {
+  TapstackFile,
+  TapstackFolder,
+  FileUploadOptions,
+  FileListResponse,
+  FolderListResponse,
+} from '../types';
+
+export class FileModule {
+  constructor(private adapter: IInstanceAdapter) { }
+
+  // ==================== Files ====================
+
+  /**
+   * List files in the workspace (optionally filtered by folder)
+   */
+  async list(folderId?: string): Promise<FileListResponse> {
+    const params: Record<string, string> = {};
+    if (folderId) params.folderId = folderId;
+
+    return this.adapter.request<FileListResponse>('GET', 'files/list', { params });
+  }
+
+  /**
+   * Get a single file by ID
+   */
+  async get(fileId: string): Promise<TapstackFile> {
+    return this.adapter.request<TapstackFile>('GET', `files/${fileId}`);
+  }
+
+  /**
+   * Upload a file
+   */
+  async upload(file: File | Blob, options?: FileUploadOptions): Promise<TapstackFile> {
+    const metadata: Record<string, string> = {};
+    if (options?.folderId) metadata.folderId = options.folderId;
+    if (options?.folder) metadata.folder = options.folder;
+
+    return this.adapter.upload<TapstackFile>('files/upload', file, metadata);
+  }
+
+  /**
+   * Delete a file
+   */
+  async delete(fileId: string): Promise<{ deleted: boolean }> {
+    return this.adapter.request<{ deleted: boolean }>('DELETE', `files/${fileId}`);
+  }
+
+  /**
+   * Get a signed download URL for a file
+   */
+  async getDownloadUrl(fileId: string, expiresIn = 3600): Promise<{ url: string }> {
+    return this.adapter.request<{ url: string }>(
+      'GET',
+      `files/${fileId}/download`,
+      { params: { expiresIn: String(expiresIn) } }
+    );
+  }
+
+  /**
+   * Move a file to a different folder
+   */
+  async move(fileId: string, targetFolderId: string | null): Promise<TapstackFile> {
+    return this.adapter.request<TapstackFile>('PATCH', `files/${fileId}/move`, {
+      body: { folderId: targetFolderId },
+    });
+  }
+
+  /**
+   * Rename a file
+   */
+  async rename(fileId: string, newName: string): Promise<TapstackFile> {
+    return this.adapter.request<TapstackFile>('PATCH', `files/${fileId}`, {
+      body: { name: newName },
+    });
+  }
+
+  // ==================== Folders ====================
+
+  /**
+   * List folders (optionally filtered by parent)
+   */
+  async listFolders(parentId?: string | null): Promise<FolderListResponse> {
+    const params: Record<string, string> = {};
+    if (parentId !== undefined) {
+      params.parentId = parentId ?? 'null';
+    }
+
+    return this.adapter.request<FolderListResponse>('GET', 'files/folders', { params });
+  }
+
+  /**
+   * Get a single folder by ID
+   */
+  async getFolder(folderId: string): Promise<TapstackFolder> {
+    return this.adapter.request<TapstackFolder>('GET', `files/folders/${folderId}`);
+  }
+
+  /**
+   * Create a new folder
+   */
+  async createFolder(name: string, parentId?: string): Promise<TapstackFolder> {
+    return this.adapter.request<TapstackFolder>('POST', 'files/folders', {
+      body: { name, parentId },
+    });
+  }
+
+  /**
+   * Rename a folder
+   */
+  async renameFolder(folderId: string, newName: string): Promise<TapstackFolder> {
+    return this.adapter.request<TapstackFolder>('PATCH', `files/folders/${folderId}`, {
+      body: { name: newName },
+    });
+  }
+
+  /**
+   * Move a folder to a different parent
+   */
+  async moveFolder(folderId: string, targetParentId: string | null): Promise<TapstackFolder> {
+    return this.adapter.request<TapstackFolder>('PATCH', `files/folders/${folderId}/move`, {
+      body: { parentId: targetParentId },
+    });
+  }
+
+  /**
+   * Delete a folder (and all contents)
+   */
+  async deleteFolder(folderId: string): Promise<{ deleted: boolean }> {
+    return this.adapter.request<{ deleted: boolean }>('DELETE', `files/folders/${folderId}`);
+  }
+}
+
+
+
+
+
+

package/src/modules/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Modules Index
+ * Export all module classes
+ */
+
+export * from './objects';
+export * from './fields';
+export * from './records';
+export * from './organizations';
+export * from './workspaces';
+export * from './files';
+export * from './automations';
+export * from './conversations';
+
+
+
+
+
+

package/src/modules/objects.ts

@@ -1,27 +1,59 @@
-import { AxiosInstance } from 'axios';
-import { handleRequest } from '../request';
-import { TapstackObject, TapstackResponse } from '../types';
+/**
+ * Objects Module
+ * CRUD operations for Tapstack objects (data models)
+ */
+
+import { IInstanceAdapter } from '../adapters/types';
+import {
+  TapstackObject,
+  CreateObjectPayload,
+  UpdateObjectPayload,
+  ObjectListResponse,
+} from '../types';
 
 export class ObjectModule {
-  constructor(private client: AxiosInstance) {}
+  constructor(private adapter: IInstanceAdapter) { }
 
-  get(slug: string): Promise<TapstackResponse<TapstackObject>> {
-    return handleRequest(this.client, { method: 'GET', url: `/system/${slug}` });
+  /**
+   * List all objects in the workspace
+   */
+  async list(): Promise<ObjectListResponse> {
+    return this.adapter.request<ObjectListResponse>('GET', 'schema/objects');
   }
 
-  list(): Promise<TapstackResponse<TapstackObject[]>> {
-    return handleRequest(this.client, { method: 'GET', url: `/system` });
+  /**
+   * Get a single object by slug
+   */
+  async get(slug: string): Promise<TapstackObject> {
+    return this.adapter.request<TapstackObject>('GET', `schema/objects/${slug}`);
   }
 
-  create(data: Partial<TapstackObject>): Promise<TapstackResponse<TapstackObject>> {
-    return handleRequest(this.client, { method: 'POST', url: `/system`, data });
+  /**
+   * Create a new object
+   */
+  async create(data: CreateObjectPayload): Promise<TapstackObject> {
+    return this.adapter.request<TapstackObject>('POST', 'schema/objects', {
+      body: data,
+    });
   }
 
-  update(slug: string, data: Partial<TapstackObject>): Promise<TapstackResponse<TapstackObject>> {
-    return handleRequest(this.client, { method: 'PUT', url: `/system/${slug}`, data });
+  /**
+   * Update an existing object
+   */
+  async update(slug: string, data: UpdateObjectPayload): Promise<TapstackObject> {
+    return this.adapter.request<TapstackObject>('PATCH', `schema/objects/${slug}`, {
+      body: data,
+    });
   }
 
-  delete(slug: string): Promise<TapstackResponse<void>> {
-    return handleRequest(this.client, { method: 'DELETE', url: `/system/${slug}` });
+  /**
+   * Delete an object (soft delete by default)
+   */
+  async delete(slug: string, soft = true): Promise<{ deleted: boolean }> {
+    return this.adapter.request<{ deleted: boolean }>(
+      'DELETE',
+      `schema/objects/${slug}`,
+      { params: { soft: String(soft) } }
+    );
   }
 }