supatool 0.5.0 → 0.6.1

package/dist/sync/config.js

@@ -73,12 +73,13 @@ function loadConfig(configPath) {
 function resolveConfig(options, configPath) {
     const fileConfig = loadConfig(configPath);
     const connectionString = options.connectionString ||
+        process.env.DB_CONNECTION_STRING ||
         process.env.SUPABASE_CONNECTION_STRING ||
         process.env.DATABASE_URL ||
         fileConfig.connectionString;
     return {
         connectionString,
-        schemaDir: options.schemaDir || fileConfig.schemaDir || './supabase/schemas',
+        schemaDir: options.schemaDir || fileConfig.schemaDir || './db/schemas',
         tablePattern: options.tablePattern || fileConfig.tablePattern || '*',
         migration: fileConfig.migration
     };
@@ -88,12 +89,12 @@ function resolveConfig(options, configPath) {
  */
 function createConfigTemplate(outputPath) {
     const template = {
-        schemaDir: "./supabase/schemas",
+        schemaDir: "./db/schemas",
         tablePattern: "*",
         migration: {
             naming: "timestamp",
             "_naming_comment": "Use 'sequential' for NNN_description.sql format, 'timestamp' for YYYYMMDDHHMMSS_description.sql",
-            dir: "supabase/migrations"
+            dir: "db/migrations"
         },
         "_comment": "Set credentials in .env.local — never put secrets in this file."
     };
@@ -111,12 +112,12 @@ function ensureEnvLocalTemplate() {
         return;
     const template = [
         '# supatool credentials — never commit this file',
-        '# Option A: Supabase URL + service role key (recommended)',
-        'SUPABASE_URL=https://your-project-ref.supabase.co',
-        'SUPABASE_SERVICE_ROLE_KEY=your-service-role-key',
+        '# PostgreSQL connection string (Cloud SQL, Supabase, or any PostgreSQL)',
+        'DB_CONNECTION_STRING=postgresql://user:password@host:port/database',
         '',
-        '# Option B: direct connection string',
+        '# Legacy aliases (still accepted for backward compatibility)',
         '# SUPABASE_CONNECTION_STRING=postgresql://user:password@host:port/database',
+        '# DATABASE_URL=postgresql://user:password@host:port/database',
     ].join('\n') + '\n';
     fs.writeFileSync(envLocalPath, template, 'utf-8');
     console.log('.env.local template created — fill in your credentials.');

package/dist/sync/definitionExtractor.js

@@ -1039,7 +1039,7 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
 /**
  * Save definitions to files (merge RLS/triggers into table/view; schema folders when multi-schema)
  */
-async function saveDefinitionsByType(definitions, outputDir, separateDirectories = true, schemas = ['public'], relations = [], rpcTables = [], allSchemas = [], version, tableRlsStatus = []) {
+async function saveDefinitionsByType(definitions, outputDir, separateDirectories = true, schemas = ['public'], relations = [], rpcTables = [], allSchemas = [], version, tableRlsStatus = [], force = false) {
     const fs = await Promise.resolve().then(() => __importStar(require('fs')));
     const path = await Promise.resolve().then(() => __importStar(require('path')));
     const outputDate = new Date().toLocaleDateString('en-CA', { year: 'numeric', month: '2-digit', day: '2-digit' });
@@ -1128,6 +1128,7 @@ async function saveDefinitionsByType(definitions, outputDir, separateDirectories
         fs.mkdirSync(outputDir, { recursive: true });
     }
     const fsPromises = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+    const writtenPaths = new Set();
     for (const def of toWrite) {
         const typeDir = typeDirNames[def.type];
         const baseTypeDir = separateDirectories ? typeDir : '.';
@@ -1140,7 +1141,32 @@ async function saveDefinitionsByType(definitions, outputDir, separateDirectories
         const fileName = `${def.name}.sql`;
         const filePath = path.join(targetDir, fileName);
         const ddlWithNewline = def.ddl.endsWith('\n') ? def.ddl : def.ddl + '\n';
-        await fsPromises.writeFile(filePath, headerComment + ddlWithNewline);
+        const newContent = headerComment + ddlWithNewline;
+        writtenPaths.add(filePath);
+        // Skip write if content unchanged (ignore header line which contains the date)
+        if (fs.existsSync(filePath)) {
+            const existingContent = await fsPromises.readFile(filePath, 'utf8');
+            const stripHeader = (c) => c.split('\n').slice(1).join('\n');
+            if (stripHeader(existingContent) === stripHeader(newContent)) {
+                continue;
+            }
+        }
+        await fsPromises.writeFile(filePath, newContent);
+    }
+    // When force: delete SQL files that no longer correspond to any extracted object
+    if (force && fs.existsSync(outputDir)) {
+        const deleteStaleSqlFiles = (dir) => {
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    deleteStaleSqlFiles(fullPath);
+                }
+                else if (entry.name.endsWith('.sql') && !writtenPaths.has(fullPath)) {
+                    fs.unlinkSync(fullPath);
+                }
+            }
+        };
+        deleteStaleSqlFiles(outputDir);
     }
     await generateIndexFile(toWrite, outputDir, separateDirectories, multiSchema, relations, rpcTables, allSchemas, schemas, version, tableRlsStatus);
 }
@@ -1344,7 +1370,9 @@ async function generateIndexFile(definitions, outputDir, separateDirectories = t
  * Classify and output definitions
  */
 async function extractDefinitions(options) {
-    const { connectionString, outputDir, separateDirectories = true, tablesOnly = false, viewsOnly = false, all = false, tablePattern = '*', force = false, schemas = ['public'], version } = options;
+    const { connectionString, outputDir, separateDirectories = true, tablesOnly = false, viewsOnly = false, all = false, tablePattern = '*', force = false, schemas: schemasOption = ['public'], excludeSchemas = [], allSchemas: useAllSchemas = false, schemasExplicit = false, version } = options;
+    // schemas will be resolved after DB connect when useAllSchemas is true
+    let schemas = schemasOption;
     // Disable Node.js SSL certificate verification
     process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
     // Connection string validation
@@ -1463,6 +1491,18 @@ async function extractDefinitions(options) {
         console.log(`   Connection string length: ${encodedConnectionString.length}`);
         await client.connect();
         spinner.text = 'Connected to database';
+        // Resolve schemas: --all-schemas or -e alone (without explicit --schema) → fetch all from DB and subtract excludeSchemas
+        const useAllSchemasEffective = useAllSchemas || (excludeSchemas.length > 0 && !schemasExplicit);
+        if (useAllSchemasEffective) {
+            const SYSTEM_SCHEMAS = ['information_schema', 'pg_catalog', 'pg_toast', 'pg_temp_1', 'pg_toast_temp_1'];
+            const discovered = await fetchAllSchemas(client);
+            schemas = discovered.filter(s => !SYSTEM_SCHEMAS.includes(s) && !excludeSchemas.includes(s));
+            console.log(`Schemas (all minus excluded): ${schemas.join(', ')}`);
+        }
+        else if (excludeSchemas.length > 0) {
+            schemas = schemas.filter(s => !excludeSchemas.includes(s));
+            console.log(`Schemas (filtered): ${schemas.join(', ')}`);
+        }
         let allDefinitions = [];
         // Initialize progress tracker
         const progress = {
@@ -1611,13 +1651,9 @@ async function extractDefinitions(options) {
                 console.warn('RLS status fetch skipped:', err);
             }
         }
-        // When force: remove output dir then write (so removed tables don't leave files)
-        if (force && fs.existsSync(outputDir)) {
-            fs.rmSync(outputDir, { recursive: true });
-        }
         // Save definitions (table+RLS+triggers merged, schema folders)
         spinner.text = 'Saving definitions to files...';
-        await saveDefinitionsByType(allDefinitions, outputDir, separateDirectories, schemas, relations, rpcTables, allSchemas, version, tableRlsStatus);
+        await saveDefinitionsByType(allDefinitions, outputDir, separateDirectories, schemas, relations, rpcTables, allSchemas, version, tableRlsStatus, force);
         // Warn at extract time when any table has RLS disabled
         const rlsNotEnabled = tableRlsStatus.filter(s => !s.rlsEnabled);
         if (rlsNotEnabled.length > 0) {

package/dist/sync/fetchRemoteSchemas.js

@@ -56,8 +56,10 @@ async function fetchRemoteSchemas(connectionString, targetTableNames) {
     // console.log('Connecting to database...');
     try {
         // Basic connection string check
-        if (!connectionString || !connectionString.startsWith('postgresql://')) {
-            throw new Error('Invalid connection string. Please specify a valid postgresql:// format.');
+        if (!connectionString ||
+            (!connectionString.startsWith('postgresql://') &&
+                !connectionString.startsWith('postgres://'))) {
+            throw new Error('Invalid connection string. Please specify a valid postgresql:// or postgres:// format.');
         }
         // Parse URL and display connection info
         const url = new URL(connectionString);

package/dist/sync/generateMigration.js

@@ -140,7 +140,7 @@ function generateAlterStatements(tableName, fromDdl, toDdl) {
  * Generate migration file
  */
 async function generateMigrationFile(tableName, fromDdl, toDdl, projectDir = '.', migrationConfig) {
-    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'supabase/migrations');
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
     // Create migrations directory
     if (!fs.existsSync(migrationDir)) {
         fs.mkdirSync(migrationDir, { recursive: true });
@@ -209,7 +209,7 @@ function analyzeDiffForTemplate(fromDdl, toDdl) {
  * Generate manual migration template
  */
 async function generateManualMigrationTemplate(tableName, fromDdl, toDdl, projectDir, migrationConfig) {
-    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'supabase/migrations');
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
     if (!fs.existsSync(migrationDir)) {
         fs.mkdirSync(migrationDir, { recursive: true });
     }
@@ -282,7 +282,7 @@ ${migrationStatements.join('\n')}
  * (old exists on remote, new exists on local, columns are highly similar)
  */
 async function generateRenameTableMigrationFile(schema, oldName, newName, projectDir = '.', migrationConfig) {
-    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'supabase/migrations');
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
     if (!fs.existsSync(migrationDir)) {
         fs.mkdirSync(migrationDir, { recursive: true });
     }
@@ -320,7 +320,7 @@ async function generateFunctionMigrationFile(schema, funcName, localDdl, remoteD
     const normalizedRemote = normalizeFunctionDdl(remoteDdl);
     if (normalizedLocal === normalizedRemote)
         return null;
-    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'supabase/migrations');
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
     if (!fs.existsSync(migrationDir)) {
         fs.mkdirSync(migrationDir, { recursive: true });
     }
@@ -342,7 +342,7 @@ ${normalizedLocal.endsWith(';') ? normalizedLocal : normalizedLocal + ';'}
 async function generateRlsMigrationFile(changedPolicies, droppedPolicies, projectDir = '.', migrationConfig) {
     if (changedPolicies.length === 0 && droppedPolicies.length === 0)
         return null;
-    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'supabase/migrations');
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
     if (!fs.existsSync(migrationDir)) {
         fs.mkdirSync(migrationDir, { recursive: true });
     }

package/dist/sync/migrateRemote.js

@@ -0,0 +1,114 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateRemote = migrateRemote;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pg_1 = require("pg");
+const MIGRATIONS_TABLE = '_supatool_migrations';
+/**
+ * Apply pending SQL migration files to remote DB.
+ *
+ * Tracks applied migrations in _supatool_migrations table.
+ * Files are applied in alphabetical order (timestamp or sequential naming).
+ */
+async function migrateRemote(options) {
+    const { connectionString, migrationsDir, dryRun = false } = options;
+    // Collect .sql files
+    if (!fs.existsSync(migrationsDir)) {
+        console.error(`❌ Migrations directory not found: ${migrationsDir}`);
+        process.exit(1);
+    }
+    const allFiles = fs.readdirSync(migrationsDir)
+        .filter(f => f.endsWith('.sql'))
+        .sort();
+    if (allFiles.length === 0) {
+        console.log('No migration files found.');
+        return;
+    }
+    const client = new pg_1.Client({
+        connectionString,
+        ssl: { rejectUnauthorized: false }
+    });
+    try {
+        await client.connect();
+        // Ensure tracking table exists
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
+        id         SERIAL PRIMARY KEY,
+        filename   TEXT NOT NULL UNIQUE,
+        applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
+      )
+    `);
+        // Get already-applied migrations
+        const applied = await client.query(`SELECT filename FROM ${MIGRATIONS_TABLE} ORDER BY filename`);
+        const appliedSet = new Set(applied.rows.map(r => r.filename));
+        const pending = allFiles.filter(f => !appliedSet.has(f));
+        if (pending.length === 0) {
+            console.log('✅ All migrations already applied.');
+            return;
+        }
+        console.log(`Pending migrations: ${pending.length}`);
+        for (const f of pending) {
+            console.log(`  • ${f}`);
+        }
+        if (dryRun) {
+            console.log('\n(dry-run) No changes applied.');
+            return;
+        }
+        // Apply each pending migration in a transaction
+        for (const filename of pending) {
+            const filepath = path.join(migrationsDir, filename);
+            const sql = fs.readFileSync(filepath, 'utf-8');
+            process.stdout.write(`Applying ${filename}... `);
+            await client.query('BEGIN');
+            try {
+                await client.query(sql);
+                await client.query(`INSERT INTO ${MIGRATIONS_TABLE} (filename) VALUES ($1)`, [filename]);
+                await client.query('COMMIT');
+                console.log('✅');
+            }
+            catch (err) {
+                await client.query('ROLLBACK');
+                console.log('❌');
+                throw err;
+            }
+        }
+        console.log(`\n✅ Applied ${pending.length} migration(s).`);
+    }
+    finally {
+        await client.end();
+    }
+}

package/dist/sync/seedGenerator.js

@@ -56,6 +56,7 @@ function parseTablesYaml(yamlPath) {
  * @param options SeedGenOptions
  */
 async function generateSeedsFromRemote(options) {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
     const tables = parseTablesYaml(options.tablesYamlPath);
     // Generate datetime subdir name (e.g. 20250705_1116_supatool)
     const now = new Date();
@@ -67,7 +68,10 @@ async function generateSeedsFromRemote(options) {
     const folderName = `${y}${m}${d}_${hh}${mm}_supatool`;
     const outDir = path_1.default.join(options.outputDir, folderName);
     // DB connection
-    const client = new pg_1.Client({ connectionString: options.connectionString });
+    const client = new pg_1.Client({
+        connectionString: options.connectionString,
+        ssl: { rejectUnauthorized: false }
+    });
     await client.connect();
     const processedFiles = [];
     for (const { schema, table } of tables) {
@@ -77,8 +81,15 @@ async function generateSeedsFromRemote(options) {
             fs_1.default.mkdirSync(schemaDir, { recursive: true });
         }
         // Fetch data
-        const res = await client.query(`SELECT * FROM "${schema}"."${table}"`);
-        const rows = res.rows;
+        let rows;
+        try {
+            const res = await client.query(`SELECT * FROM "${schema}"."${table}"`);
+            rows = res.rows;
+        }
+        catch (err) {
+            console.warn(`⚠️  Skip: ${schema}.${table} — ${err.message}`);
+            continue;
+        }
         // Output JSON
         const fileName = `${table}_seed.json`;
         const filePath = path_1.default.join(schemaDir, fileName);
@@ -118,7 +129,7 @@ async function generateSeedsFromRemote(options) {
 }
 /** Utility to get table comment */
 async function getTableComment(connectionString, schema, table) {
-    const client = new pg_1.Client({ connectionString });
+    const client = new pg_1.Client({ connectionString, ssl: { rejectUnauthorized: false } });
     await client.connect();
     try {
         const res = await client.query(`SELECT obj_description(c.oid) as comment FROM pg_class c JOIN pg_namespace n ON c.relnamespace = n.oid WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'r'`, [table, schema]);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "supatool",
-  "version": "0.5.0",
-  "description": "CLI for Supabase: extract schema (tables, views, RLS, RPC) to files + llms.txt for LLM, deploy local schema, seed export. CRUD code gen deprecated.",
+  "version": "0.6.1",
+  "description": "CLI for PostgreSQL (Cloud SQL / Supabase): extract schema to files, deploy schema diffs, apply migrations, seed export.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -9,6 +9,7 @@
   },
 "scripts": {
   "build": "tsc",
+  "test": "npm run build && node test/smoke.js",
   "start": "tsx src/bin/supatool.ts",
   "local": "tsx src/bin/supatool.ts"
 },
@@ -17,18 +18,26 @@
     "bin"
   ],
   "keywords": [
+    "postgresql",
+    "cloud-sql",
     "supabase",
-    "crud",
     "cli",
     "typescript",
-    "React",
     "postgres",
-    "database"
+    "database",
+    "migration"
   ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/idea-garage/supatool"
+  },
+  "homepage": "https://github.com/idea-garage/supatool#readme",
+  "bugs": {
+    "url": "https://github.com/idea-garage/supatool/issues"
+  },
   "author": "IdeaGarage",
   "license": "MIT",
   "dependencies": {
-    "@supabase/supabase-js": "^2.49.4",
     "commander": "^13.1.0",
     "diff": "^5.2.0",
     "dotenv": "^16.5.0",

package/dist/integrations/supabase/crud-autogen/tasks.js

@@ -1,220 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTasksByFilters = getTasksByFilters;
-exports.getTasksSingleByFilters = getTasksSingleByFilters;
-exports.getTasksById = getTasksById;
-exports.createTasks = createTasks;
-exports.updateTasks = updateTasks;
-exports.deleteTasks = deleteTasks;
-exports.queryTasks = queryTasks;
-// Supabase CRUD operations for tasks
-// This file is automatically generated. Do not edit it directly.
-const client_1 = require("../client");
-// Function to apply filters to a query
-function applyFilters(query, filters) {
-    for (const [key, value] of Object.entries(filters)) {
-        if (Array.isArray(value)) {
-            query = query.in(key, value); // Use 'in' for array values
-        }
-        else if (typeof value === 'object' && value !== null) {
-            for (const [operator, val] of Object.entries(value)) {
-                switch (operator) {
-                    case 'eq':
-                        query = query.eq(key, val);
-                        break;
-                    case 'neq':
-                        query = query.neq(key, val);
-                        break;
-                    case 'like':
-                        query = query.like(key, val);
-                        break;
-                    case 'ilike':
-                        query = query.ilike(key, val);
-                        break;
-                    case 'lt':
-                        query = query.lt(key, val);
-                        break;
-                    case 'lte':
-                        query = query.lte(key, val);
-                        break;
-                    case 'gte':
-                        query = query.gte(key, val);
-                        break;
-                    case 'gt':
-                        query = query.gt(key, val);
-                        break;
-                    case 'contains':
-                        query = query.contains(key, val);
-                        break;
-                    case 'contains_any':
-                        query = query.contains_any(key, val);
-                        break;
-                    case 'contains_all':
-                        query = query.contains_all(key, val);
-                        break;
-                    // Add more operators as needed
-                    default:
-                        throw new Error('Unsupported operator: ' + operator);
-                }
-            }
-        }
-        else {
-            query = query.eq(key, value); // Default to 'eq' for simple values
-        }
-    }
-    return query;
-}
-// Read multiple rows with dynamic filters
-async function getTasksByFilters({ filters }) {
-    try {
-        let query = client_1.supabase.from('tasks').select('*');
-        query = applyFilters(query, filters);
-        const result = await query;
-        if (result.error) {
-            throw new Error(`Failed to fetch tasks: ${result.error.message}`);
-        }
-        return result.data || [];
-    }
-    catch (error) {
-        console.error('Error in getTasksByFilters:', error);
-        throw error;
-    }
-}
-// Read a single row with dynamic filters
-async function getTasksSingleByFilters({ filters }) {
-    try {
-        let query = client_1.supabase.from('tasks').select('*');
-        query = applyFilters(query, filters).single();
-        const result = await query;
-        if (result.error) {
-            if (result.error.code === 'PGRST116') {
-                return null;
-            }
-            throw new Error(`Failed to fetch tasks: ${result.error.message}`);
-        }
-        return result.data;
-    }
-    catch (error) {
-        console.error('Error in getTasksSingleByFilters:', error);
-        throw error;
-    }
-}
-// Read single row using id
-async function getTasksById({ id }) {
-    if (!id) {
-        throw new Error('ID is required');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .select('*')
-            .eq('id', id)
-            .single();
-        if (result.error) {
-            if (result.error.code === 'PGRST116') {
-                return null;
-            }
-            throw new Error(`Failed to fetch tasks: ${result.error.message}`);
-        }
-        return result.data;
-    }
-    catch (error) {
-        console.error('Error in getTasksById:', error);
-        throw error;
-    }
-}
-// Create Function
-async function createTasks({ data }) {
-    if (!data) {
-        throw new Error('Data is required for creation');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .insert([data])
-            .select()
-            .single();
-        if (result.error) {
-            throw new Error(`Failed to create tasks: ${result.error.message}`);
-        }
-        if (!result.data) {
-            throw new Error('No data returned after creation');
-        }
-        return result.data;
-    }
-    catch (error) {
-        console.error('Error in createTasks:', error);
-        throw error;
-    }
-}
-// Update Function
-async function updateTasks({ id, data }) {
-    if (!id) {
-        throw new Error('ID is required for update');
-    }
-    if (!data || Object.keys(data).length === 0) {
-        throw new Error('Update data is required');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .update(data)
-            .eq('id', id)
-            .select()
-            .single();
-        if (result.error) {
-            if (result.error.code === 'PGRST116') {
-                throw new Error(`tasks with ID ${id} not found`);
-            }
-            throw new Error(`Failed to update tasks: ${result.error.message}`);
-        }
-        if (!result.data) {
-            throw new Error(`tasks with ID ${id} not found`);
-        }
-        return result.data;
-    }
-    catch (error) {
-        console.error('Error in updateTasks:', error);
-        throw error;
-    }
-}
-// Delete Function
-async function deleteTasks({ id }) {
-    if (!id) {
-        throw new Error('ID is required for deletion');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .delete()
-            .eq('id', id);
-        if (result.error) {
-            throw new Error(`Failed to delete tasks: ${result.error.message}`);
-        }
-        return true;
-    }
-    catch (error) {
-        console.error('Error in deleteTasks:', error);
-        throw error;
-    }
-}
-// Custom query function
-async function queryTasks({ query }) {
-    if (!query) {
-        throw new Error('Query is required');
-    }
-    try {
-        const result = await client_1.supabase
-            .from('tasks')
-            .select(query);
-        if (result.error) {
-            throw new Error(`Failed to execute query: ${result.error.message}`);
-        }
-        return result.data || [];
-    }
-    catch (error) {
-        console.error('Error in queryTasks:', error);
-        throw error;
-    }
-}
-// All functions are exported individually above