@tapstack/db 1.0.6 → 3.0.0

package/dist/modules/automations.d.ts

@@ -0,0 +1,109 @@
+/**
+ * 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 declare class AutomationModule {
+    private adapter;
+    constructor(adapter: IInstanceAdapter);
+    /**
+     * List all automations for the current workspace
+     */
+    list(): Promise<{
+        automations: Automation[];
+    }>;
+    /**
+     * Get a single automation by ID
+     */
+    get(id: string): Promise<Automation>;
+    /**
+     * Create a new automation
+     */
+    create(data: CreateAutomationPayload): Promise<Automation>;
+    /**
+     * Update an existing automation
+     */
+    update(id: string, data: UpdateAutomationPayload): Promise<Automation>;
+    /**
+     * Delete an automation
+     */
+    delete(id: string, soft?: boolean): Promise<{
+        deleted: boolean;
+    }>;
+    /**
+     * Toggle automation enabled/disabled
+     */
+    toggle(id: string): Promise<Automation>;
+    /**
+     * Execute an automation manually (for testing)
+     */
+    execute(id: string, testData?: Record<string, unknown>): Promise<ExecuteAutomationResult>;
+}

package/dist/modules/automations.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Automations Module
+ * CRUD operations for workflow automations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutomationModule = void 0;
+class AutomationModule {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * List all automations for the current workspace
+     */
+    async list() {
+        return this.adapter.request('GET', 'automations');
+    }
+    /**
+     * Get a single automation by ID
+     */
+    async get(id) {
+        return this.adapter.request('GET', `automations/${id}`);
+    }
+    /**
+     * Create a new automation
+     */
+    async create(data) {
+        return this.adapter.request('POST', 'automations', {
+            body: data,
+        });
+    }
+    /**
+     * Update an existing automation
+     */
+    async update(id, data) {
+        return this.adapter.request('PUT', `automations/${id}`, {
+            body: data,
+        });
+    }
+    /**
+     * Delete an automation
+     */
+    async delete(id, soft = true) {
+        return this.adapter.request('DELETE', `automations/${id}`, { params: { soft: String(soft) } });
+    }
+    /**
+     * Toggle automation enabled/disabled
+     */
+    async toggle(id) {
+        return this.adapter.request('POST', `automations/${id}/toggle`);
+    }
+    /**
+     * Execute an automation manually (for testing)
+     */
+    async execute(id, testData) {
+        return this.adapter.request('POST', `automations/${id}/execute`, { body: testData });
+    }
+}
+exports.AutomationModule = AutomationModule;

package/dist/modules/conversations.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 declare class ConversationModule {
+    private adapter;
+    constructor(adapter: IInstanceAdapter);
+    /**
+     * List conversations for the current user/workspace
+     */
+    list(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<ConversationListResponse>;
+    /**
+     * Get a single conversation with messages
+     */
+    get(id: string): Promise<ConversationWithMessages>;
+    /**
+     * Create a new conversation
+     */
+    create(data?: CreateConversationPayload): Promise<{
+        conversation: ConversationWithMessages;
+    }>;
+    /**
+     * Update a conversation (title)
+     */
+    update(id: string, title: string): Promise<{
+        conversation: Conversation;
+    }>;
+    /**
+     * Delete a conversation
+     */
+    delete(id: string): Promise<{
+        deleted: boolean;
+    }>;
+    /**
+     * Add a message to a conversation
+     */
+    addMessage(conversationId: string, message: AddMessagePayload): Promise<{
+        message: Message;
+    }>;
+}

package/dist/modules/conversations.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Conversations Module
+ * AI chat conversation management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationModule = void 0;
+class ConversationModule {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    /**
+     * List conversations for the current user/workspace
+     */
+    async list(options) {
+        const params = {};
+        if (options?.limit)
+            params.limit = String(options.limit);
+        if (options?.offset)
+            params.offset = String(options.offset);
+        return this.adapter.request('GET', 'conversations', { params });
+    }
+    /**
+     * Get a single conversation with messages
+     */
+    async get(id) {
+        return this.adapter.request('GET', `conversations/${id}`);
+    }
+    /**
+     * Create a new conversation
+     */
+    async create(data) {
+        return this.adapter.request('POST', 'conversations', { body: data || {} });
+    }
+    /**
+     * Update a conversation (title)
+     */
+    async update(id, title) {
+        return this.adapter.request('PATCH', `conversations/${id}`, { body: { title } });
+    }
+    /**
+     * Delete a conversation
+     */
+    async delete(id) {
+        return this.adapter.request('DELETE', `conversations/${id}`);
+    }
+    /**
+     * Add a message to a conversation
+     */
+    async addMessage(conversationId, message) {
+        return this.adapter.request('POST', `conversations/${conversationId}/messages`, { body: message });
+    }
+}
+exports.ConversationModule = ConversationModule;

package/dist/modules/fields.d.ts

@@ -1,11 +1,32 @@
-import { AxiosInstance } from 'axios';
-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 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>>;
+    private adapter;
+    constructor(adapter: IInstanceAdapter);
+    /**
+     * List all fields for an object
+     */
+    list(objectSlug: string): Promise<FieldListResponse>;
+    /**
+     * Get a single field by ID
+     */
+    get(objectSlug: string, fieldId: string): Promise<TapstackField>;
+    /**
+     * Create a new field
+     */
+    create(objectSlug: string, data: CreateFieldPayload): Promise<TapstackField>;
+    /**
+     * Update an existing field
+     */
+    update(objectSlug: string, fieldId: string, data: UpdateFieldPayload): Promise<TapstackField>;
+    /**
+     * Delete a field (soft delete by default)
+     */
+    delete(objectSlug: string, fieldId: string, soft?: boolean): Promise<{
+        deleted: boolean;
+    }>;
 }

package/dist/modules/fields.js

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

package/dist/modules/files.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Files Module
+ * File and folder operations using Supabase Storage
+ */
+import { IInstanceAdapter } from '../adapters/types';
+import { TapstackFile, TapstackFolder, FileUploadOptions, FileListResponse, FolderListResponse } from '../types';
+export declare class FileModule {
+    private adapter;
+    constructor(adapter: IInstanceAdapter);
+    /**
+     * List files in the workspace (optionally filtered by folder)
+     */
+    list(folderId?: string): Promise<FileListResponse>;
+    /**
+     * Get a single file by ID
+     */
+    get(fileId: string): Promise<TapstackFile>;
+    /**
+     * Upload a file
+     */
+    upload(file: File | Blob, options?: FileUploadOptions): Promise<TapstackFile>;
+    /**
+     * Delete a file
+     */
+    delete(fileId: string): Promise<{
+        deleted: boolean;
+    }>;
+    /**
+     * Get a signed download URL for a file
+     */
+    getDownloadUrl(fileId: string, expiresIn?: number): Promise<{
+        url: string;
+    }>;
+    /**
+     * Move a file to a different folder
+     */
+    move(fileId: string, targetFolderId: string | null): Promise<TapstackFile>;
+    /**
+     * Rename a file
+     */
+    rename(fileId: string, newName: string): Promise<TapstackFile>;
+    /**
+     * List folders (optionally filtered by parent)
+     */
+    listFolders(parentId?: string | null): Promise<FolderListResponse>;
+    /**
+     * Get a single folder by ID
+     */
+    getFolder(folderId: string): Promise<TapstackFolder>;
+    /**
+     * Create a new folder
+     */
+    createFolder(name: string, parentId?: string): Promise<TapstackFolder>;
+    /**
+     * Rename a folder
+     */
+    renameFolder(folderId: string, newName: string): Promise<TapstackFolder>;
+    /**
+     * Move a folder to a different parent
+     */
+    moveFolder(folderId: string, targetParentId: string | null): Promise<TapstackFolder>;
+    /**
+     * Delete a folder (and all contents)
+     */
+    deleteFolder(folderId: string): Promise<{
+        deleted: boolean;
+    }>;
+}

package/dist/modules/files.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Files Module
+ * File and folder operations using Supabase Storage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileModule = void 0;
+class FileModule {
+    constructor(adapter) {
+        this.adapter = adapter;
+    }
+    // ==================== Files ====================
+    /**
+     * List files in the workspace (optionally filtered by folder)
+     */
+    async list(folderId) {
+        const params = {};
+        if (folderId)
+            params.folderId = folderId;
+        return this.adapter.request('GET', 'files/list', { params });
+    }
+    /**
+     * Get a single file by ID
+     */
+    async get(fileId) {
+        return this.adapter.request('GET', `files/${fileId}`);
+    }
+    /**
+     * Upload a file
+     */
+    async upload(file, options) {
+        const metadata = {};
+        if (options?.folderId)
+            metadata.folderId = options.folderId;
+        if (options?.folder)
+            metadata.folder = options.folder;
+        return this.adapter.upload('files/upload', file, metadata);
+    }
+    /**
+     * Delete a file
+     */
+    async delete(fileId) {
+        return this.adapter.request('DELETE', `files/${fileId}`);
+    }
+    /**
+     * Get a signed download URL for a file
+     */
+    async getDownloadUrl(fileId, expiresIn = 3600) {
+        return this.adapter.request('GET', `files/${fileId}/download`, { params: { expiresIn: String(expiresIn) } });
+    }
+    /**
+     * Move a file to a different folder
+     */
+    async move(fileId, targetFolderId) {
+        return this.adapter.request('PATCH', `files/${fileId}/move`, {
+            body: { folderId: targetFolderId },
+        });
+    }
+    /**
+     * Rename a file
+     */
+    async rename(fileId, newName) {
+        return this.adapter.request('PATCH', `files/${fileId}`, {
+            body: { name: newName },
+        });
+    }
+    // ==================== Folders ====================
+    /**
+     * List folders (optionally filtered by parent)
+     */
+    async listFolders(parentId) {
+        const params = {};
+        if (parentId !== undefined) {
+            params.parentId = parentId ?? 'null';
+        }
+        return this.adapter.request('GET', 'files/folders', { params });
+    }
+    /**
+     * Get a single folder by ID
+     */
+    async getFolder(folderId) {
+        return this.adapter.request('GET', `files/folders/${folderId}`);
+    }
+    /**
+     * Create a new folder
+     */
+    async createFolder(name, parentId) {
+        return this.adapter.request('POST', 'files/folders', {
+            body: { name, parentId },
+        });
+    }
+    /**
+     * Rename a folder
+     */
+    async renameFolder(folderId, newName) {
+        return this.adapter.request('PATCH', `files/folders/${folderId}`, {
+            body: { name: newName },
+        });
+    }
+    /**
+     * Move a folder to a different parent
+     */
+    async moveFolder(folderId, targetParentId) {
+        return this.adapter.request('PATCH', `files/folders/${folderId}/move`, {
+            body: { parentId: targetParentId },
+        });
+    }
+    /**
+     * Delete a folder (and all contents)
+     */
+    async deleteFolder(folderId) {
+        return this.adapter.request('DELETE', `files/folders/${folderId}`);
+    }
+}
+exports.FileModule = FileModule;

package/dist/modules/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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/dist/modules/index.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Modules Index
+ * Export all module classes
+ */
+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("./objects"), exports);
+__exportStar(require("./fields"), exports);
+__exportStar(require("./records"), exports);
+__exportStar(require("./organizations"), exports);
+__exportStar(require("./workspaces"), exports);
+__exportStar(require("./files"), exports);
+__exportStar(require("./automations"), exports);
+__exportStar(require("./conversations"), exports);

package/dist/modules/objects.d.ts

@@ -1,11 +1,32 @@
-import { AxiosInstance } from 'axios';
-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 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>>;
+    private adapter;
+    constructor(adapter: IInstanceAdapter);
+    /**
+     * List all objects in the workspace
+     */
+    list(): Promise<ObjectListResponse>;
+    /**
+     * Get a single object by slug
+     */
+    get(slug: string): Promise<TapstackObject>;
+    /**
+     * Create a new object
+     */
+    create(data: CreateObjectPayload): Promise<TapstackObject>;
+    /**
+     * Update an existing object
+     */
+    update(slug: string, data: UpdateObjectPayload): Promise<TapstackObject>;
+    /**
+     * Delete an object (soft delete by default)
+     */
+    delete(slug: string, soft?: boolean): Promise<{
+        deleted: boolean;
+    }>;
 }