supatool 0.3.0 → 0.3.2

package/README.md

@@ -2,6 +2,7 @@
 
 A CLI tool that automatically generates TypeScript CRUD code from Supabase type definitions.
 
+
 ## Install
 
 ```
@@ -155,7 +156,7 @@ CRUD utility files for the `apps` table will be generated in `src/integrations/s
 You can import and use these functions in your application as follows:
 
 ```ts
-// Example: Using CRUD functions for the apps table
+// Example: Using CRUD functions for the apps table (v0.3.0+)
 import {
   selectAppsRowsWithFilters,
   selectAppsSingleRowWithFilters,
@@ -165,23 +166,26 @@ import {
   deleteAppsRow,
 } from 'src/integrations/supabase/crud-autogen/apps';
 
-// Get multiple rows with filters
-const apps = await selectAppsRowsWithFilters({ status: 'active' });
+// Select multiple rows with filters (NEW: destructuring parameters)
+const apps = await selectAppsRowsWithFilters({ filters: { status: 'active' } });
 
-// Get a single row with filters
-const app = await selectAppsSingleRowWithFilters({ id: 'your-app-id' });
+// Select a single row with filters
+const app = await selectAppsSingleRowWithFilters({ filters: { id: 'your-app-id' } });
 
-// Get by ID
-const appById = await selectAppsRowById('your-app-id');
+// Select by ID (NEW: destructuring parameters)
+const appById = await selectAppsRowById({ id: 'your-app-id' });
 
-// Create new row
-const newApp = await insertAppsRow({ name: 'New App', status: 'active' });
+// Insert new row (NEW: destructuring parameters)
+const newApp = await insertAppsRow({ data: { name: 'New App', status: 'active' } });
 
-// Update row
-const updatedApp = await updateAppsRow({ id: 'your-app-id', name: 'Updated Name' });
+// Update row (NEW: destructuring parameters)
+const updatedApp = await updateAppsRow({ 
+  id: 'your-app-id', 
+  data: { name: 'Updated Name' } 
+});
 
-// Delete row
-const deletedApp = await deleteAppsRow('your-app-id');
+// Delete row (NEW: destructuring parameters)
+const success = await deleteAppsRow({ id: 'your-app-id' });
 ```
 
 - All functions are async and return the corresponding row type.
@@ -281,6 +285,43 @@ supatool extract --all -c "postgresql://..." -o supabase/schemas
 
 ## Changelog
 
+### v0.3.2
+
+- **ENHANCED**: Adjust for extensions(vector, geometry etc.)
+- **FIXED**: USER-DEFINED column types are now rendered with full type definitions (e.g. `vector(1536)`, `geometry(Point,4326)`).
+- **ADDED**: `FOREIGN KEY` constraints are now included as `CONSTRAINT ... FOREIGN KEY ... REFERENCES ...` inside generated `CREATE TABLE` statements.
+
+### v0.3.0
+
+**NEW Features:**
+- **NEW**: `extract` command for database schema extraction
+- **NEW**: Full compliance with Supabase declarative database schemas workflow
+- **NEW**: AI-friendly index.md and llms.txt generation for better schema understanding
+- **NEW**: Database comment extraction and integration
+- **NEW**: Organized directory structure (tables/, views/, rls/, rpc/)
+- **NEW**: Pattern matching for selective extraction
+- **ENHANCED**: Support for all database object types (RLS, functions, triggers, cron jobs, custom types)
+- **ENHANCED**: Flexible output options with --no-separate compatibility
+
+**Enhanced Error Handling:**
+- Comprehensive try-catch blocks for all CRUD operations
+- Enhanced null/undefined checks with proper fallbacks
+- Detailed error messages with contextual information
+- Special handling for PGRST116 errors (record not found)
+- Parameter validation for required fields
+- Proper error logging and debugging support
+
+**Breaking Changes:**
+- **Function Parameter Format**: All CRUD functions now use destructuring assignment
+  - Before: `selectTableRowById(id: string)`
+  - After: `selectTableRowById({ id }: { id: string })`
+- **Type Safety**: Enhanced TypeScript type annotations for all functions
+
+### v0.2.0
+- Added `gen:` commands for code and schema generation
+- Enhanced `create` command  
+- Introduced model schema support (`schemas/supatool-data.schema.ts`)
+
 ## Database Comments
 
 Supatool automatically extracts and includes PostgreSQL comments in all generated files. Comments enhance documentation and AI understanding of your schema.
@@ -313,21 +354,4 @@ Comments appear in:
 ## Tables
 - [users](tables/users.sql) - User account information and authentication data
 - [posts](tables/posts.sql) - User-generated content and blog posts
-```
-
-## Changelog
-
-### v0.3.0
-- **NEW**: `extract` command for database schema extraction
-- **NEW**: Full compliance with Supabase declarative database schemas workflow
-- **NEW**: AI-friendly index.md and llms.txt generation for better schema understanding
-- **NEW**: Database comment extraction and integration
-- **NEW**: Organized directory structure (tables/, views/, rls/, rpc/)
-- **NEW**: Pattern matching for selective extraction
-- **ENHANCED**: Support for all database object types (RLS, functions, triggers, cron jobs, custom types)
-- **ENHANCED**: Flexible output options with --no-separate compatibility
-
-### v0.2.0
-- Added `gen:` commands for code and schema generation
-- Enhanced `create` command  
-- Introduced model schema support (`schemas/supatool-data.schema.ts`)
+```

package/dist/generator/crudGenerator.js

@@ -34,21 +34,158 @@ function generateCrudFromModel(model, outDir) {
         if (tableObj.skipCreate)
             continue;
         const tableName = tableObj.tableName;
+        const capitalizedName = capitalize(tableName);
         let code = `// 自動生成: ${tableName}用CRUD関数\n\n`;
         code += `import { supabase } from '../client';\n`;
         code += `import type { ${tableName} } from '../types';\n\n`;
+        // 型定義
+        code += `// フィルター型定義\n`;
+        code += `type FilterValue = string | number | boolean | null;\n`;
+        code += `type Filters = Record<string, FilterValue | FilterValue[]>;\n\n`;
+        // 全件取得関数（改良版）
         code += `/** 全件取得 */\n`;
-        code += `export async function getAll${capitalize(tableName)}(): Promise<${tableName}[]> {\n`;
-        code += `  const { data, error } = await supabase.from('${tableName}').select('*');\n`;
-        code += `  if (error) throw error;\n`;
-        code += `  return data as ${tableName}[];\n`;
+        code += `export async function select${capitalizedName}Rows(): Promise<${tableName}[]> {\n`;
+        code += `  try {\n`;
+        code += `    const { data, error } = await supabase.from('${tableName}').select('*');\n`;
+        code += `    if (error) {\n`;
+        code += `      console.error('Error fetching all ${tableName}:', error);\n`;
+        code += `      throw new Error(\`Failed to fetch ${tableName}: \${error.message}\`);\n`;
+        code += `    }\n`;
+        code += `    if (!data) {\n`;
+        code += `      return [];\n`;
+        code += `    }\n`;
+        code += `    return data as ${tableName}[];\n`;
+        code += `  } catch (error) {\n`;
+        code += `    console.error('Unexpected error in select${capitalizedName}Rows:', error);\n`;
+        code += `    throw error;\n`;
+        code += `  }\n`;
         code += `}\n\n`;
+        // IDで1件取得関数（改良版）
         code += `/** IDで1件取得 */\n`;
-        code += `export async function get${capitalize(tableName)}ById(id: string): Promise<${tableName} | null> {\n`;
-        code += `  const { data, error } = await supabase.from('${tableName}').select('*').eq('id', id).single();\n`;
-        code += `  if (error) throw error;\n`;
-        code += `  return data as ${tableName} | null;\n`;
-        code += `}\n`;
+        code += `export async function select${capitalizedName}RowById({ id }: { id: string }): Promise<${tableName} | null> {\n`;
+        code += `  if (!id) {\n`;
+        code += `    throw new Error('ID is required');\n`;
+        code += `  }\n`;
+        code += `  try {\n`;
+        code += `    const { data, error } = await supabase.from('${tableName}').select('*').eq('id', id).single();\n`;
+        code += `    if (error) {\n`;
+        code += `      // レコードが見つからない場合（PGRST116）は null を返す\n`;
+        code += `      if (error.code === 'PGRST116') {\n`;
+        code += `        return null;\n`;
+        code += `      }\n`;
+        code += `      console.error('Error fetching ${tableName} by ID:', error);\n`;
+        code += `      throw new Error(\`Failed to fetch ${tableName} with ID \${id}: \${error.message}\`);\n`;
+        code += `    }\n`;
+        code += `    return data as ${tableName} | null;\n`;
+        code += `  } catch (error) {\n`;
+        code += `    console.error('Unexpected error in select${capitalizedName}RowById:', error);\n`;
+        code += `    throw error;\n`;
+        code += `  }\n`;
+        code += `}\n\n`;
+        // フィルターで検索関数
+        code += `/** フィルターで複数件取得 */\n`;
+        code += `export async function select${capitalizedName}RowsWithFilters({ filters }: { filters: Filters }): Promise<${tableName}[]> {\n`;
+        code += `  try {\n`;
+        code += `    let query = supabase.from('${tableName}').select('*');\n`;
+        code += `    \n`;
+        code += `    // フィルターを適用\n`;
+        code += `    for (const [key, value] of Object.entries(filters)) {\n`;
+        code += `      if (Array.isArray(value)) {\n`;
+        code += `        query = query.in(key, value);\n`;
+        code += `      } else {\n`;
+        code += `        query = query.eq(key, value);\n`;
+        code += `      }\n`;
+        code += `    }\n`;
+        code += `    \n`;
+        code += `    const { data, error } = await query;\n`;
+        code += `    if (error) {\n`;
+        code += `      console.error('Error fetching ${tableName} by filters:', error);\n`;
+        code += `      throw new Error(\`Failed to fetch ${tableName}: \${error.message}\`);\n`;
+        code += `    }\n`;
+        code += `    return (data as unknown as ${tableName}[]) || [];\n`;
+        code += `  } catch (error) {\n`;
+        code += `    console.error('Unexpected error in select${capitalizedName}RowsWithFilters:', error);\n`;
+        code += `    throw error;\n`;
+        code += `  }\n`;
+        code += `}\n\n`;
+        // 作成関数
+        code += `/** 新規作成 */\n`;
+        code += `export async function insert${capitalizedName}Row({ data }: { data: Omit<${tableName}, 'id' | 'created_at' | 'updated_at'> }): Promise<${tableName}> {\n`;
+        code += `  if (!data) {\n`;
+        code += `    throw new Error('Data is required for creation');\n`;
+        code += `  }\n`;
+        code += `  try {\n`;
+        code += `    const { data: createdData, error } = await supabase\n`;
+        code += `      .from('${tableName}')\n`;
+        code += `      .insert([data])\n`;
+        code += `      .select()\n`;
+        code += `      .single();\n`;
+        code += `    if (error) {\n`;
+        code += `      console.error('Error creating ${tableName}:', error);\n`;
+        code += `      throw new Error(\`Failed to create ${tableName}: \${error.message}\`);\n`;
+        code += `    }\n`;
+        code += `    if (!createdData) {\n`;
+        code += `      throw new Error('No data returned after creation');\n`;
+        code += `    }\n`;
+        code += `    return createdData as ${tableName};\n`;
+        code += `  } catch (error) {\n`;
+        code += `    console.error('Unexpected error in insert${capitalizedName}Row:', error);\n`;
+        code += `    throw error;\n`;
+        code += `  }\n`;
+        code += `}\n\n`;
+        // 更新関数
+        code += `/** 更新 */\n`;
+        code += `export async function update${capitalizedName}Row({ id, data }: { id: string; data: Partial<Omit<${tableName}, 'id' | 'created_at'>> }): Promise<${tableName}> {\n`;
+        code += `  if (!id) {\n`;
+        code += `    throw new Error('ID is required for update');\n`;
+        code += `  }\n`;
+        code += `  if (!data || Object.keys(data).length === 0) {\n`;
+        code += `    throw new Error('Update data is required');\n`;
+        code += `  }\n`;
+        code += `  try {\n`;
+        code += `    const { data: updatedData, error } = await supabase\n`;
+        code += `      .from('${tableName}')\n`;
+        code += `      .update(data)\n`;
+        code += `      .eq('id', id)\n`;
+        code += `      .select()\n`;
+        code += `      .single();\n`;
+        code += `    if (error) {\n`;
+        code += `      if (error.code === 'PGRST116') {\n`;
+        code += `        throw new Error(\`${tableName} with ID \${id} not found\`);\n`;
+        code += `      }\n`;
+        code += `      console.error('Error updating ${tableName}:', error);\n`;
+        code += `      throw new Error(\`Failed to update ${tableName} with ID \${id}: \${error.message}\`);\n`;
+        code += `    }\n`;
+        code += `    if (!updatedData) {\n`;
+        code += `      throw new Error(\`${tableName} with ID \${id} not found\`);\n`;
+        code += `    }\n`;
+        code += `    return updatedData as ${tableName};\n`;
+        code += `  } catch (error) {\n`;
+        code += `    console.error('Unexpected error in update${capitalizedName}Row:', error);\n`;
+        code += `    throw error;\n`;
+        code += `  }\n`;
+        code += `}\n\n`;
+        // 削除関数
+        code += `/** 削除 */\n`;
+        code += `export async function delete${capitalizedName}Row({ id }: { id: string }): Promise<boolean> {\n`;
+        code += `  if (!id) {\n`;
+        code += `    throw new Error('ID is required for deletion');\n`;
+        code += `  }\n`;
+        code += `  try {\n`;
+        code += `    const { error } = await supabase\n`;
+        code += `      .from('${tableName}')\n`;
+        code += `      .delete()\n`;
+        code += `      .eq('id', id);\n`;
+        code += `    if (error) {\n`;
+        code += `      console.error('Error deleting ${tableName}:', error);\n`;
+        code += `      throw new Error(\`Failed to delete ${tableName} with ID \${id}: \${error.message}\`);\n`;
+        code += `    }\n`;
+        code += `    return true;\n`;
+        code += `  } catch (error) {\n`;
+        code += `    console.error('Unexpected error in delete${capitalizedName}Row:', error);\n`;
+        code += `    throw error;\n`;
+        code += `  }\n`;
+        code += `}\n\n`;
         fs_1.default.writeFileSync(path_1.default.join(outDir, `${tableName}.ts`), code);
     }
 }

package/dist/generator/sqlGenerator.js

@@ -49,6 +49,7 @@ function generateSqlFromModel(model, outPath) {
         let userIdCount = userIdFields.length;
         sql += `CREATE TABLE ${tableName} (\n`;
         const colDefs = [];
+        const tableConstraints = [];
         for (const [colName, col] of Object.entries(t.fields || {})) {
             const c = col;
             let actualColName = colName;
@@ -66,18 +67,23 @@ function generateSqlFromModel(model, outPath) {
             let def = `  ${actualColName} ${toSqlType(c.type, actualColName)}`;
             if (c.primary)
                 def += ' PRIMARY KEY';
+            if (c.unique)
+                def += ' UNIQUE';
             if (c.notNull)
                 def += ' NOT NULL';
             if (c.default)
                 def += ` DEFAULT ${c.default}`;
-            // 外部キー制約はREFERENCESで付与
+            // 外部キー制約はテーブル末尾に付与するため保留
+            colDefs.push(def);
+            // 外部キー制約をテーブル末尾に格納
             if (c.ref) {
                 const refTable = c.ref.split('.')[0];
-                def += ` REFERENCES ${refTable}(id)`;
+                tableConstraints.push(`  FOREIGN KEY (${actualColName}) REFERENCES ${refTable}(id)`);
             }
-            colDefs.push(def);
         }
-        sql += colDefs.join(',\n') + '\n);\n\n';
+        // 列定義 + テーブルレベル制約を結合
+        const defs = [...colDefs, ...tableConstraints];
+        sql += defs.join(',\n') + '\n);\n\n';
         // ALTER TABLEによる外部キー制約は出力しない
         sql += '\n';
     }
@@ -89,12 +95,20 @@ function toSqlType(type, colName) {
     // 時刻列は必ずtimestamptz
     if (type === 'timestamp' || type === 'timestamptz' || colName.endsWith('_at'))
         return 'timestamptz';
+    // vector型サポート
+    if (/^vector(\(\d+\))?$/i.test(type))
+        return type;
+    // extensions.vector → vector へ変換
+    const extVectorMatch = type.match(/^extensions\.vector(\(\d+\))?$/i);
+    if (extVectorMatch) {
+        return `vector${extVectorMatch[1] || ''}`;
+    }
     switch (type) {
         case 'uuid': return 'uuid';
         case 'text': return 'text';
         case 'int':
         case 'integer': return 'integer';
         case 'boolean': return 'boolean';
-        default: return 'text';
+        default: return type; // 指定が未知の場合はそのまま返す
     }
 }

package/dist/index.js

@@ -161,13 +161,13 @@ const toUpperCamelCase = (str) => {
 // CRUD template
 const crudTemplate = (typeName, fields, isView) => {
     const upperCamelTypeName = toUpperCamelCase(typeName);
-    const selectByIdFunctionName = 'select' + upperCamelTypeName + 'RowById';
-    const selectFilteredRowsFunctionName = 'select' + upperCamelTypeName + 'RowsWithFilters';
-    const selectFilteredSingleRowFunctionName = 'select' + upperCamelTypeName + 'SingleRowWithFilters';
-    const insertFunctionName = 'insert' + upperCamelTypeName + 'Row';
+    const getByIdFunctionName = 'select' + upperCamelTypeName + 'RowById';
+    const getByFiltersFunctionName = 'select' + upperCamelTypeName + 'RowsWithFilters';
+    const getSingleByFiltersFunctionName = 'select' + upperCamelTypeName + 'SingleRowWithFilters';
+    const createFunctionName = 'insert' + upperCamelTypeName + 'Row';
     const updateFunctionName = 'update' + upperCamelTypeName + 'Row';
     const deleteFunctionName = 'delete' + upperCamelTypeName + 'Row';
-    const idType = fields.find((field) => field.name === 'id')?.type;
+    const idType = fields.find((field) => field.name === 'id')?.type || 'string';
     const hasIdColumn = idType !== undefined; // Check if 'id' column exists
     const exportHeaders = `// Supabase CRUD operations for ${typeName}
 // This file is automatically generated. Do not edit it directly.
@@ -180,17 +180,29 @@ type Filters = Record<string, FilterTypesValue | FilterTypesValue[]>;
 `;
     const exportSelectById = `
 // Read single row using id
-async function ${selectByIdFunctionName}(id: ${idType}): Promise<${typeName} | ${typeName}[]> {
-    if (id !== undefined) {
+export async function ${getByIdFunctionName}({ id }: { id: ${idType} }): Promise<${typeName} | null> {
+    if (!id) {
+        throw new Error('ID is required');
+    }
+    try {
         const result = await supabase
             .from('${typeName.toLowerCase()}')
             .select('*')
             .eq('id', id)
             .single();
+        
+        if (result.error) {
+            if (result.error.code === 'PGRST116') {
+                return null;
+            }
+            throw new Error(\`Failed to fetch ${typeName}: \${result.error.message}\`);
+        }
+        
         return result.data as ${typeName};
+    } catch (error) {
+        console.error('Error in ${getByIdFunctionName}:', error);
+        throw error;
     }
-    const result = await supabase.from('${typeName.toLowerCase()}').select('*');
-    return result.data as ${typeName}[];
 }
 `;
     const exportSelectQueries = `
@@ -248,64 +260,138 @@ function applyFilters(query: any, filters: Filters): any {
 }
 
 // Read multiple rows with dynamic filters
-async function ${selectFilteredRowsFunctionName}(filters: Filters = {}): Promise<${typeName}[]> {
-    let query = supabase.from('${typeName.toLowerCase()}').select('*');
-    query = applyFilters(query, filters);
+export async function ${getByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName}[]> {
+    try {
+        let query = supabase.from('${typeName.toLowerCase()}').select('*');
+        query = applyFilters(query, filters);
 
-    const result = await query;
-    return result.data as ${typeName}[];
+        const result = await query;
+        
+        if (result.error) {
+            throw new Error(\`Failed to fetch ${typeName}: \${result.error.message}\`);
+        }
+        
+        return (result.data as unknown as ${typeName}[]) || [];
+    } catch (error) {
+        console.error('Error in ${getByFiltersFunctionName}:', error);
+        throw error;
+    }
 }
 
 // Read a single row with dynamic filters
-async function ${selectFilteredSingleRowFunctionName}(filters: Filters = {}): Promise<${typeName}> {
-    let query = supabase.from('${typeName.toLowerCase()}').select('*');
-    query = applyFilters(query, filters).single();
+export async function ${getSingleByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName} | null> {
+    try {
+        let query = supabase.from('${typeName.toLowerCase()}').select('*');
+        query = applyFilters(query, filters).single();
 
-    const result = await query;
-    return result.data as unknown as ${typeName};
+        const result = await query;
+        
+        if (result.error) {
+            if (result.error.code === 'PGRST116') {
+                return null;
+            }
+            throw new Error(\`Failed to fetch ${typeName}: \${result.error.message}\`);
+        }
+        
+        return result.data as unknown as ${typeName};
+    } catch (error) {
+        console.error('Error in ${getSingleByFiltersFunctionName}:', error);
+        throw error;
+    }
 }
 `;
     const exportInsertOperation = isView ? '' :
         `
 // Create Function
-async function ${insertFunctionName}(data: TablesInsert<'${typeName}'>): Promise<${typeName}> {
-    const result = await supabase
-        .from('${typeName}')
-        .insert([data])
-        .select()
-        .single();
+export async function ${createFunctionName}({ data }: { data: TablesInsert<'${typeName}'> }): Promise<${typeName}> {
+    if (!data) {
+        throw new Error('Data is required for creation');
+    }
+    try {
+        const result = await supabase
+            .from('${typeName}')
+            .insert([data])
+            .select()
+            .single();
 
-    if (result.data) {
+        if (result.error) {
+            throw new Error(\`Failed to create ${typeName}: \${result.error.message}\`);
+        }
+        
+        if (!result.data) {
+            throw new Error('No data returned after creation');
+        }
+        
         return result.data as ${typeName};
+    } catch (error) {
+        console.error('Error in ${createFunctionName}:', error);
+        throw error;
     }
-    throw new Error('Failed to insert data');
 }
 `;
     const exportUpdateOperation = isView ? '' :
         `
 // Update Function
-async function ${updateFunctionName}(data: TablesUpdate<'${typeName}'> & { id: ${idType} }): Promise<${typeName}> {
-    const result = await supabase.from('${typeName.toLowerCase()}').update(data).eq('id', data.id).select().single();
-    if (result.data) {
+export async function ${updateFunctionName}({ id, data }: { id: ${idType}; data: TablesUpdate<'${typeName}'> }): Promise<${typeName}> {
+    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 supabase
+            .from('${typeName.toLowerCase()}')
+            .update(data)
+            .eq('id', id)
+            .select()
+            .single();
+            
+        if (result.error) {
+            if (result.error.code === 'PGRST116') {
+                throw new Error(\`${typeName} with ID \${id} not found\`);
+            }
+            throw new Error(\`Failed to update ${typeName}: \${result.error.message}\`);
+        }
+        
+        if (!result.data) {
+            throw new Error(\`${typeName} with ID \${id} not found\`);
+        }
+        
         return result.data as ${typeName};
+    } catch (error) {
+        console.error('Error in ${updateFunctionName}:', error);
+        throw error;
     }
-    throw new Error('Failed to update data');
 }
 `;
     const exportDeleteOperation = isView ? '' :
         `
 // Delete Function
-async function ${deleteFunctionName}(id: ${idType}): Promise<${typeName}> {
-    const result = await supabase.from('${typeName.toLowerCase()}').delete().eq('id', id).select().single();
-    if (result.data) {
-        return result.data as ${typeName};
+export async function ${deleteFunctionName}({ id }: { id: ${idType} }): Promise<boolean> {
+    if (!id) {
+        throw new Error('ID is required for deletion');
+    }
+    try {
+        const result = await supabase
+            .from('${typeName.toLowerCase()}')
+            .delete()
+            .eq('id', id);
+            
+        if (result.error) {
+            throw new Error(\`Failed to delete ${typeName}: \${result.error.message}\`);
+        }
+        
+        return true;
+    } catch (error) {
+        console.error('Error in ${deleteFunctionName}:', error);
+        throw error;
     }
-    throw new Error('Failed to delete data');
 }
 `;
     // Export all functions
     const exportAll = `
-export { ${selectFilteredRowsFunctionName}, ${selectFilteredSingleRowFunctionName}${hasIdColumn ? ', ' + selectByIdFunctionName : ''}${isView ? '' : ', ' + insertFunctionName + ', ' + updateFunctionName + ', ' + deleteFunctionName} };
+// All functions are exported individually above
 `;
     // Return all the code
     return exportHeaders + exportSelectQueries + (hasIdColumn ? exportSelectById : '') + exportInsertOperation + exportUpdateOperation + exportDeleteOperation + exportAll;

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

@@ -0,0 +1,220 @@
+"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

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

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkflowsByFilters = getWorkflowsByFilters;
+exports.getWorkflowsSingleByFilters = getWorkflowsSingleByFilters;
+exports.getWorkflowsById = getWorkflowsById;
+exports.createWorkflows = createWorkflows;
+exports.updateWorkflows = updateWorkflows;
+exports.deleteWorkflows = deleteWorkflows;
+exports.queryWorkflows = queryWorkflows;
+// Supabase CRUD operations for workflows
+// 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 getWorkflowsByFilters({ filters }) {
+    try {
+        let query = client_1.supabase.from('workflows').select('*');
+        query = applyFilters(query, filters);
+        const result = await query;
+        if (result.error) {
+            throw new Error(`Failed to fetch workflows: ${result.error.message}`);
+        }
+        return result.data || [];
+    }
+    catch (error) {
+        console.error('Error in getWorkflowsByFilters:', error);
+        throw error;
+    }
+}
+// Read a single row with dynamic filters
+async function getWorkflowsSingleByFilters({ filters }) {
+    try {
+        let query = client_1.supabase.from('workflows').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 workflows: ${result.error.message}`);
+        }
+        return result.data;
+    }
+    catch (error) {
+        console.error('Error in getWorkflowsSingleByFilters:', error);
+        throw error;
+    }
+}
+// Read single row using id
+async function getWorkflowsById({ id }) {
+    if (!id) {
+        throw new Error('ID is required');
+    }
+    try {
+        const result = await client_1.supabase
+            .from('workflows')
+            .select('*')
+            .eq('id', id)
+            .single();
+        if (result.error) {
+            if (result.error.code === 'PGRST116') {
+                return null;
+            }
+            throw new Error(`Failed to fetch workflows: ${result.error.message}`);
+        }
+        return result.data;
+    }
+    catch (error) {
+        console.error('Error in getWorkflowsById:', error);
+        throw error;
+    }
+}
+// Create Function
+async function createWorkflows({ data }) {
+    if (!data) {
+        throw new Error('Data is required for creation');
+    }
+    try {
+        const result = await client_1.supabase
+            .from('workflows')
+            .insert([data])
+            .select()
+            .single();
+        if (result.error) {
+            throw new Error(`Failed to create workflows: ${result.error.message}`);
+        }
+        if (!result.data) {
+            throw new Error('No data returned after creation');
+        }
+        return result.data;
+    }
+    catch (error) {
+        console.error('Error in createWorkflows:', error);
+        throw error;
+    }
+}
+// Update Function
+async function updateWorkflows({ 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('workflows')
+            .update(data)
+            .eq('id', id)
+            .select()
+            .single();
+        if (result.error) {
+            if (result.error.code === 'PGRST116') {
+                throw new Error(`workflows with ID ${id} not found`);
+            }
+            throw new Error(`Failed to update workflows: ${result.error.message}`);
+        }
+        if (!result.data) {
+            throw new Error(`workflows with ID ${id} not found`);
+        }
+        return result.data;
+    }
+    catch (error) {
+        console.error('Error in updateWorkflows:', error);
+        throw error;
+    }
+}
+// Delete Function
+async function deleteWorkflows({ id }) {
+    if (!id) {
+        throw new Error('ID is required for deletion');
+    }
+    try {
+        const result = await client_1.supabase
+            .from('workflows')
+            .delete()
+            .eq('id', id);
+        if (result.error) {
+            throw new Error(`Failed to delete workflows: ${result.error.message}`);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error('Error in deleteWorkflows:', error);
+        throw error;
+    }
+}
+// Custom query function
+async function queryWorkflows({ query }) {
+    if (!query) {
+        throw new Error('Query is required');
+    }
+    try {
+        const result = await client_1.supabase
+            .from('workflows')
+            .select(query);
+        if (result.error) {
+            throw new Error(`Failed to execute query: ${result.error.message}`);
+        }
+        return result.data || [];
+    }
+    catch (error) {
+        console.error('Error in queryWorkflows:', error);
+        throw error;
+    }
+}
+// All functions are exported individually above

package/dist/sync/definitionExtractor.js

@@ -717,19 +717,24 @@ async function fetchTableDefinitions(client, spinner, progress, schemas = ['publ
  */
 async function generateCreateTableDDL(client, tableName, schemaName = 'public') {
     // 全てのクエリを並行実行
-    const [columnsResult, primaryKeyResult, tableCommentResult, columnCommentsResult, uniqueConstraintResult] = await Promise.all([
+    const [columnsResult, primaryKeyResult, tableCommentResult, columnCommentsResult, uniqueConstraintResult, foreignKeyResult] = await Promise.all([
         // カラム情報を取得
         client.query(`
       SELECT 
-        column_name,
-        data_type,
-        character_maximum_length,
-        is_nullable,
-        column_default
-      FROM information_schema.columns 
-      WHERE table_schema = $1 
-        AND table_name = $2
-      ORDER BY ordinal_position
+        c.column_name,
+        c.data_type,
+        c.udt_name,
+        c.character_maximum_length,
+        c.is_nullable,
+        c.column_default,
+        pg_catalog.format_type(a.atttypid, a.atttypmod) AS full_type
+      FROM information_schema.columns c
+      JOIN pg_class cl ON cl.relname = c.table_name
+      JOIN pg_namespace ns ON ns.nspname = c.table_schema AND ns.oid = cl.relnamespace
+      JOIN pg_attribute a ON a.attrelid = cl.oid AND a.attname = c.column_name
+      WHERE c.table_schema = $1 
+        AND c.table_name = $2
+      ORDER BY c.ordinal_position
     `, [schemaName, tableName]),
         // 主キー情報を取得
         client.query(`
@@ -776,6 +781,25 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
         AND tc.constraint_type = 'UNIQUE'
       GROUP BY tc.constraint_name
       ORDER BY tc.constraint_name
+    `, [schemaName, tableName]),
+        // FOREIGN KEY制約を取得
+        client.query(`
+      SELECT 
+        tc.constraint_name,
+        string_agg(kcu.column_name, ', ' ORDER BY kcu.ordinal_position) as columns,
+        ccu.table_schema AS foreign_table_schema,
+        ccu.table_name AS foreign_table_name,
+        string_agg(ccu.column_name, ', ' ORDER BY kcu.ordinal_position) as foreign_columns
+      FROM information_schema.table_constraints tc
+      JOIN information_schema.key_column_usage kcu 
+        ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+      JOIN information_schema.constraint_column_usage ccu 
+        ON tc.constraint_name = ccu.constraint_name AND tc.table_schema = ccu.table_schema
+      WHERE tc.table_schema = $1
+        AND tc.table_name = $2
+        AND tc.constraint_type = 'FOREIGN KEY'
+      GROUP BY tc.constraint_name, ccu.table_schema, ccu.table_name
+      ORDER BY tc.constraint_name
     `, [schemaName, tableName])
     ]);
     const columnComments = new Map();
@@ -798,7 +822,9 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
     ddl += `CREATE TABLE IF NOT EXISTS ${tableName} (\n`;
     const columnDefs = [];
     for (const col of columnsResult.rows) {
-        let colDef = `  ${col.column_name} ${col.data_type.toUpperCase()}`;
+        const rawType = col.full_type ||
+            ((col.data_type === 'USER-DEFINED' && col.udt_name) ? col.udt_name : col.data_type);
+        let colDef = `  ${col.column_name} ${rawType}`;
         // 長さ指定
         if (col.character_maximum_length) {
             colDef += `(${col.character_maximum_length})`;
@@ -823,6 +849,10 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
     for (const unique of uniqueConstraintResult.rows) {
         ddl += `,\n  CONSTRAINT ${unique.constraint_name} UNIQUE (${unique.columns})`;
     }
+    // FOREIGN KEY制約をCREATE TABLE内に追加
+    for (const fk of foreignKeyResult.rows) {
+        ddl += `,\n  CONSTRAINT ${fk.constraint_name} FOREIGN KEY (${fk.columns}) REFERENCES ${fk.foreign_table_schema}.${fk.foreign_table_name} (${fk.foreign_columns})`;
+    }
     ddl += '\n);\n';
     ddl += '\n';
     // カラムコメントを追加（スキーマ名を含む）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supatool",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "A CLI tool for Supabase schema extraction and TypeScript CRUD generation with declarative database schema support.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",