supatool 0.3.5 → 0.3.7

package/dist/generator/sqlGenerator.js

@@ -65,26 +65,54 @@ 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}`;
-            // 外部キー制約はテーブル末尾に付与するため保留
             colDefs.push(def);
-            // 外部キー制約をテーブル末尾に格納
-            if (c.ref) {
-                const refTable = c.ref.split('.')[0];
-                tableConstraints.push(`  FOREIGN KEY (${actualColName}) REFERENCES ${refTable}(id)`);
+        }
+        // 主キー制約（constraint名付き）
+        const pkCols = Object.entries(t.fields || {})
+            .filter(([_, col]) => col.primary)
+            .map(([colName, _]) => colName);
+        if (pkCols.length > 0) {
+            tableConstraints.push(`  CONSTRAINT ${tableName}_pkey PRIMARY KEY (${pkCols.join(', ')})`);
+        }
+        // ユニーク制約（constraint名付き）
+        if (Array.isArray(t.uniques)) {
+            for (const unique of t.uniques) {
+                if (Array.isArray(unique.columns) && unique.name) {
+                    tableConstraints.push(`  CONSTRAINT ${unique.name} UNIQUE (${unique.columns.join(', ')})`);
+                }
+            }
+        }
+        // 外部キー制約（constraint名付き）
+        if (Array.isArray(t.foreignKeys)) {
+            for (const fk of t.foreignKeys) {
+                if (fk.name && fk.columns && fk.refTable && fk.refColumns) {
+                    let fkStr = `  CONSTRAINT ${fk.name} FOREIGN KEY (${fk.columns.join(', ')}) REFERENCES ${fk.refTable} (${fk.refColumns.join(', ')})`;
+                    if (fk.onDelete)
+                        fkStr += ` ON DELETE ${fk.onDelete}`;
+                    if (fk.onUpdate)
+                        fkStr += ` ON UPDATE ${fk.onUpdate}`;
+                    tableConstraints.push(fkStr);
+                }
+            }
+        }
+        // チェック制約（constraint名付き）
+        if (Array.isArray(t.checkConstraints)) {
+            for (const check of t.checkConstraints) {
+                if (check.name) {
+                    tableConstraints.push(`  CONSTRAINT ${check.name} CHECK (${check.expression})`);
+                }
+                else {
+                    tableConstraints.push(`  CHECK (${check.expression})`);
+                }
             }
         }
         // 列定義 + テーブルレベル制約を結合
         const defs = [...colDefs, ...tableConstraints];
         sql += defs.join(',\n') + '\n);\n\n';
-        // ALTER TABLEによる外部キー制約は出力しない
         sql += '\n';
     }
     fs_1.default.writeFileSync(outPath, sql);

package/dist/index.js

@@ -82,36 +82,50 @@ function main() {
             const typeName = typeAliasDecl.name.text;
             const typeNode = typeAliasDecl.type;
             if (typeNode.kind === typescript_1.SyntaxKind.TypeLiteral && typeName === 'Database') {
-                const schemaName = getSchemaName(typeNode);
-                const schemaType = typeNode.members.find((member) => member.name && member.name.text === schemaName);
-                if (schemaType && schemaType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
-                    const tablesAndViewsType = schemaType.type.members.filter((member) => member.name && (member.name.text === 'Tables' || member.name.text === 'Views'));
-                    return tablesAndViewsType.flatMap((tablesOrViewsType) => {
-                        if (tablesOrViewsType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
-                            return tablesOrViewsType.type.members.map((tableOrViewMember) => {
-                                const tableName = tableOrViewMember.name.text;
-                                const isView = tablesOrViewsType.name.text === 'Views';
-                                const rowType = tableOrViewMember.type.members.find((member) => member.name && member.name.text === 'Row');
-                                if (rowType && rowType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
-                                    const fields = rowType.type.members.map((member) => {
-                                        if (member.name && member.name.kind === typescript_1.SyntaxKind.Identifier) {
-                                            const name = member.name.getText(sourceFile);
-                                            const type = member.type ? member.type.getText(sourceFile) : 'unknown';
-                                            return { name, type };
-                                        }
-                                        return { name: 'unknown', type: 'unknown' };
-                                    });
-                                    return { typeName: tableName, fields, isView };
-                                }
-                                return null;
-                            }).filter((type) => type !== null);
-                        }
-                        return [];
-                    });
-                }
+                console.log('Found Database type, processing schemas...');
+                // Database型内の全てのスキーマを処理
+                return typeNode.members.flatMap((schemaMember) => {
+                    if (schemaMember.name && schemaMember.type && schemaMember.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
+                        const schemaName = schemaMember.name.text;
+                        console.log(`Processing schema: ${schemaName}`);
+                        const schemaType = schemaMember.type;
+                        // スキーマ内のTablesとViewsを処理
+                        const tablesAndViewsType = schemaType.members.filter((member) => member.name && (member.name.text === 'Tables' || member.name.text === 'Views'));
+                        return tablesAndViewsType.flatMap((tablesOrViewsType) => {
+                            if (tablesOrViewsType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
+                                const tableCount = tablesOrViewsType.type.members.length;
+                                console.log(`Found ${tableCount} ${tablesOrViewsType.name.text} in schema ${schemaName}`);
+                                return tablesOrViewsType.type.members.map((tableOrViewMember) => {
+                                    const tableName = tableOrViewMember.name.text;
+                                    const isView = tablesOrViewsType.name.text === 'Views';
+                                    console.log(`Processing ${isView ? 'view' : 'table'}: ${tableName}`);
+                                    const rowType = tableOrViewMember.type.members.find((member) => member.name && member.name.text === 'Row');
+                                    if (rowType && rowType.type.kind === typescript_1.SyntaxKind.TypeLiteral) {
+                                        const fields = rowType.type.members.map((member) => {
+                                            if (member.name && member.name.kind === typescript_1.SyntaxKind.Identifier) {
+                                                const name = member.name.getText(sourceFile);
+                                                const type = member.type ? member.type.getText(sourceFile) : 'unknown';
+                                                return { name, type };
+                                            }
+                                            return { name: 'unknown', type: 'unknown' };
+                                        });
+                                        return { typeName: tableName, fields, isView, schema: schemaName };
+                                    }
+                                    return null;
+                                }).filter((type) => type !== null);
+                            }
+                            return [];
+                        });
+                    }
+                    return [];
+                });
             }
             return [];
         });
+        console.log(`Total types found: ${types.length}`);
+        types.forEach(type => {
+            console.log(`- ${type.schema}.${type.typeName} (${type.isView ? 'view' : 'table'}) with ${type.fields.length} fields`);
+        });
         // Show start of generation process
         console.log(`Import path: ${importPath}`);
         console.log(`Export path: ${exportPath}`);
@@ -129,23 +143,25 @@ function main() {
             return true;
         })
             .forEach(type => {
+            // スキーマごとにフォルダ分け
+            const schemaFolder = path_1.default.join(crudFolderPath, type.schema);
+            if (!(0, fs_1.existsSync)(schemaFolder)) {
+                (0, fs_1.mkdirSync)(schemaFolder, { recursive: true });
+            }
             const fileName = toLowerCamelCase(type.typeName);
-            const crudCode = crudTemplate(type.typeName, type.fields, type.isView);
-            const filePath = crudFolderPath + `${fileName}.ts`;
+            // スキーマフォルダ分けがある場合のインポートパス調整
+            const hasSchemaFolders = types.some(t => t.schema !== type.schema);
+            const crudCode = crudTemplate(type.typeName, type.fields, type.isView, type.schema, hasSchemaFolders);
+            const filePath = path_1.default.join(schemaFolder, `${fileName}.ts`);
             // Show in console
             if (type.isView) {
-                console.log(`Generating select operations only for view: ${fileName}`);
+                console.log(`Generating select operations only for view: ${type.schema}/${fileName}`);
             }
             else {
-                console.log(`Generating full CRUD operations for table: ${fileName}`);
-            }
-            // Create directory if it does not exist
-            const dirPath = filePath.substring(0, filePath.lastIndexOf('/'));
-            if (!(0, fs_1.existsSync)(dirPath)) {
-                (0, fs_1.mkdirSync)(dirPath, { recursive: true });
+                console.log(`Generating full CRUD operations for table: ${type.schema}/${fileName}`);
             }
             (0, fs_1.writeFileSync)(filePath, crudCode);
-            console.log(`Generated ${fileName}.ts`);
+            console.log(`Generated ${type.schema}/${fileName}.ts`);
         });
         console.log("CRUD operations have been generated.");
     }
@@ -158,8 +174,8 @@ const toLowerCamelCase = (str) => {
 const toUpperCamelCase = (str) => {
     return str.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
 };
-// CRUD template
-const crudTemplate = (typeName, fields, isView) => {
+// CRUDテンプレート本体 - エレガントな文字列生成
+const crudTemplate = (typeName, fields, isView, schema, hasSchemaFolders) => {
     const upperCamelTypeName = toUpperCamelCase(typeName);
     const getByIdFunctionName = 'select' + upperCamelTypeName + 'RowById';
     const getByFiltersFunctionName = 'select' + upperCamelTypeName + 'RowsWithFilters';
@@ -168,235 +184,198 @@ const crudTemplate = (typeName, fields, isView) => {
     const updateFunctionName = 'update' + upperCamelTypeName + 'Row';
     const deleteFunctionName = 'delete' + upperCamelTypeName + 'Row';
     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.
-import { supabase } from "../client";
-import { Tables, TablesInsert, TablesUpdate } from "@shared/types";
-
-type ${typeName} = Tables<'${typeName}'>;
-type FilterTypesValue = string | number | boolean | null | Record<string, any>;
-type Filters = Record<string, FilterTypesValue | FilterTypesValue[]>;
-`;
-    const exportSelectById = `
-// Read single row using id
-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 exportSelectQueries = `
-  // Function to apply filters to a query
-function applyFilters(query: any, filters: Filters): any {
-    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
-export async function ${getByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName}[]> {
-    if (!filters || typeof filters !== 'object') return [];
-    try {
-        let query = supabase.from('${typeName.toLowerCase()}').select('*');
-        query = applyFilters(query, filters);
-
-        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
-export async function ${getSingleByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName} | null> {
-    if (!filters || typeof filters !== 'object') return null;
-    try {
-        let query = supabase.from('${typeName.toLowerCase()}').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 ${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
-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.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;
-    }
-}
-`;
-    const exportUpdateOperation = isView ? '' :
-        `
-// Update Function
-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;
-    }
-}
-`;
-    const exportDeleteOperation = isView ? '' :
-        `
-// Delete Function
-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;
-    }
-}
-`;
-    // Export all functions
-    const exportAll = `
-// All functions are exported individually above
-`;
-    // Return all the code
-    return exportHeaders + exportSelectQueries + (hasIdColumn ? exportSelectById : '') + exportInsertOperation + exportUpdateOperation + exportDeleteOperation + exportAll;
+    // インポートパスを動的に調整
+    const importPath = hasSchemaFolders ? '../../client' : '../client';
+    // ヘッダー部分
+    const header = [
+        `// Supabase CRUD operations for ${typeName} (${schema} schema)`,
+        '// 自動生成ファイル',
+        `import { supabase } from "${importPath}";`,
+        'import { Tables, TablesInsert, TablesUpdate } from "@shared/types";',
+        '',
+        `type ${typeName} = Tables<'${typeName}'>;`,
+        'type FilterTypesValue = string | number | boolean | null | Record<string, any>;',
+        'type Filters = Record<string, FilterTypesValue | FilterTypesValue[]>;',
+        ''
+    ].join('\n');
+    // フィルター適用関数
+    const filterFunction = [
+        '/**',
+        ' * フィルター適用関数',
+        ' */',
+        'function applyFilters(query: any, filters: Filters): any {',
+        '  for (const [key, value] of Object.entries(filters)) {',
+        '    if (Array.isArray(value)) {',
+        '      query = query.in(key, value);',
+        '    } 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;',
+        '          default: throw new Error("Unsupported operator: " + operator);',
+        '        }',
+        '      }',
+        '    } else {',
+        '      query = query.eq(key, value);',
+        '    }',
+        '  }',
+        '  return query;',
+        '}',
+        ''
+    ].join('\n');
+    // IDで1件取得
+    const selectById = [
+        '/**',
+        ' * IDで1件取得',
+        ' */',
+        `export async function ${getByIdFunctionName}({ id }: { id: ${idType} }): Promise<${typeName} | null> {`,
+        '  if (!id) throw new Error("ID is required");',
+        '  try {',
+        '    const result = await supabase',
+        `      .schema("${schema}")`,
+        `      .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;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // フィルターで複数取得
+    const selectMultiple = [
+        '/**',
+        ' * フィルターで複数取得',
+        ' */',
+        `export async function ${getByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName}[]> {`,
+        '  if (!filters || typeof filters !== "object") return [];',
+        '  try {',
+        `    let query = supabase.schema("${schema}").from("${typeName.toLowerCase()}").select("*");`,
+        '    query = applyFilters(query, filters);',
+        '    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;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // フィルターで1件取得
+    const selectSingle = [
+        '/**',
+        ' * フィルターで1件取得',
+        ' */',
+        `export async function ${getSingleByFiltersFunctionName}({ filters }: { filters: Filters }): Promise<${typeName} | null> {`,
+        '  if (!filters || typeof filters !== "object") return null;',
+        '  try {',
+        `    let query = supabase.schema("${schema}").from("${typeName.toLowerCase()}").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 ${typeName}: \${result.error.message}\`);`,
+        '    }',
+        `    return result.data as unknown as ${typeName};`,
+        '  } catch (error) {',
+        `    console.error("Error in ${getSingleByFiltersFunctionName}:", error);`,
+        '    throw error;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // 追加（ビューでない場合のみ）
+    const insertOperation = isView ? '' : [
+        '/**',
+        ' * 追加',
+        ' */',
+        `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',
+        `      .schema("${schema}")`,
+        `      .from("${typeName.toLowerCase()}")`,
+        '      .insert([data])',
+        '      .select()',
+        '      .single();',
+        `    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;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // 更新（ビューでない場合のみ）
+    const updateOperation = isView ? '' : [
+        '/**',
+        ' * 更新',
+        ' */',
+        `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',
+        `      .schema("${schema}")`,
+        `      .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;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // 削除（ビューでない場合のみ）
+    const deleteOperation = isView ? '' : [
+        '/**',
+        ' * 削除',
+        ' */',
+        `export async function ${deleteFunctionName}({ id }: { id: ${idType} }): Promise<boolean> {`,
+        '  if (!id) throw new Error("ID is required for deletion");',
+        '  try {',
+        '    const result = await supabase',
+        `      .schema("${schema}")`,
+        `      .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;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+    // 全体を結合
+    return header + filterFunction + selectById + selectMultiple + selectSingle + insertOperation + updateOperation + deleteOperation;
 };
-// console.log(crudFolderPath);
-// console.log(types);

package/dist/sync/definitionExtractor.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractDefinitions = extractDefinitions;
+exports.generateCreateTableDDL = generateCreateTableDDL;
 const pg_1 = require("pg");
 /**
  * 進行状況を表示
@@ -869,6 +870,22 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
     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})`;
     }
+    // CHECK制約をCREATE TABLE内に追加（必ず最後）
+    const checkConstraintResult = await client.query(`
+    SELECT 
+      con.conname as constraint_name,
+      pg_get_constraintdef(con.oid) as check_clause
+    FROM pg_constraint con
+    JOIN pg_class rel ON rel.oid = con.conrelid
+    JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+    WHERE lower(rel.relname) = lower($1)
+      AND nsp.nspname = $2
+      AND con.contype = 'c'
+    ORDER BY con.conname
+  `, [tableName, schemaName]);
+    for (const check of checkConstraintResult.rows) {
+        ddl += `,\n  CONSTRAINT ${check.constraint_name} ${check.check_clause}`;
+    }
     ddl += '\n);\n\n';
     // COMMENT ON文を追加
     if (tableCommentResult.rows.length > 0 && tableCommentResult.rows[0].table_comment) {

package/dist/sync/fetchRemoteSchemas.js

@@ -37,6 +37,7 @@ exports.fetchRemoteSchemas = fetchRemoteSchemas;
 const pg_1 = require("pg");
 const dns = __importStar(require("dns"));
 const util_1 = require("util");
+const definitionExtractor_1 = require("./definitionExtractor");
 const dnsLookup = (0, util_1.promisify)(dns.lookup);
 /**
  * DDL文字列を正規化（空白・改行・タブを統一）
@@ -163,162 +164,32 @@ async function fetchRemoteSchemas(connectionString) {
         // 各テーブルのスキーマ情報を取得
         for (const row of tablesResult.rows) {
             const tableName = row.tablename;
-            // テーブルの最終更新時刻を取得（複数の方法を試行）
-            let timestamp = Math.floor(Date.now() / 1000); // デフォルト値
-            // pg_stat_user_tablesから取得
+            // テーブルの最終更新時刻を取得（省略: 既存ロジック流用）
+            let timestamp = Math.floor(Date.now() / 1000);
             try {
                 const tableStatsResult = await client.query(`
-           SELECT 
-             EXTRACT(EPOCH FROM GREATEST(
-               COALESCE(last_vacuum, '1970-01-01'::timestamp),
-               COALESCE(last_autovacuum, '1970-01-01'::timestamp),
-               COALESCE(last_analyze, '1970-01-01'::timestamp),
-               COALESCE(last_autoanalyze, '1970-01-01'::timestamp)
-             ))::bigint as last_updated
-           FROM pg_stat_user_tables 
-           WHERE relname = $1 AND schemaname = 'public'
-         `, [tableName]);
+          SELECT 
+            EXTRACT(EPOCH FROM GREATEST(
+              COALESCE(last_vacuum, '1970-01-01'::timestamp),
+              COALESCE(last_autovacuum, '1970-01-01'::timestamp),
+              COALESCE(last_analyze, '1970-01-01'::timestamp),
+              COALESCE(last_autoanalyze, '1970-01-01'::timestamp)
+            ))::bigint as last_updated
+          FROM pg_stat_user_tables 
+          WHERE relname = $1 AND schemaname = 'public'
+        `, [tableName]);
                 if (tableStatsResult.rows.length > 0 && tableStatsResult.rows[0].last_updated > 0) {
                     timestamp = tableStatsResult.rows[0].last_updated;
                 }
                 else {
-                    // デフォルトタイムスタンプ（十分に古い固定値）
                     timestamp = Math.floor(new Date('2020-01-01').getTime() / 1000);
                 }
             }
-            catch (statsError) {
-                // デフォルトタイムスタンプ（十分に古い固定値）
+            catch {
                 timestamp = Math.floor(new Date('2020-01-01').getTime() / 1000);
             }
-            // カラム情報を取得
-            const columnsResult = await client.query(`
-        SELECT 
-          column_name,
-          data_type,
-          character_maximum_length,
-          is_nullable,
-          column_default
-        FROM information_schema.columns 
-        WHERE table_schema = 'public' 
-          AND table_name = $1
-        ORDER BY ordinal_position
-      `, [tableName]);
-            // 主キー情報を取得
-            const primaryKeyResult = await client.query(`
-        SELECT column_name
-        FROM information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu 
-          ON tc.constraint_name = kcu.constraint_name
-        WHERE tc.table_schema = 'public'
-          AND tc.table_name = $1
-          AND tc.constraint_type = 'PRIMARY KEY'
-        ORDER BY kcu.ordinal_position
-      `, [tableName]);
-            // CREATE TABLE文を生成
-            let 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()}`;
-                // 長さ指定
-                if (col.character_maximum_length) {
-                    colDef += `(${col.character_maximum_length})`;
-                }
-                // NOT NULL制約
-                if (col.is_nullable === 'NO') {
-                    colDef += ' NOT NULL';
-                }
-                // デフォルト値
-                if (col.column_default) {
-                    colDef += ` DEFAULT ${col.column_default}`;
-                }
-                columnDefs.push(colDef);
-            }
-            ddl += columnDefs.join(',\n');
-            // 主キー制約
-            if (primaryKeyResult.rows.length > 0) {
-                const pkColumns = primaryKeyResult.rows.map(row => row.column_name);
-                ddl += `,\n  PRIMARY KEY (${pkColumns.join(', ')})`;
-            }
-            // UNIQUE制約を取得してCREATE TABLE内に含める
-            const uniqueConstraintResult = await client.query(`
-        SELECT 
-          tc.constraint_name,
-          string_agg(kcu.column_name, ', ' ORDER BY kcu.ordinal_position) as columns
-        FROM information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu 
-          ON tc.constraint_name = kcu.constraint_name
-        WHERE tc.table_schema = 'public'
-          AND tc.table_name = $1
-          AND tc.constraint_type = 'UNIQUE'
-        GROUP BY tc.constraint_name
-        ORDER BY tc.constraint_name
-      `, [tableName]);
-            // UNIQUE制約をCREATE TABLE内に追加
-            for (const unique of uniqueConstraintResult.rows) {
-                ddl += `,\n  CONSTRAINT ${unique.constraint_name} UNIQUE (${unique.columns})`;
-            }
-            // CHECK制約は一時的に無効化（NOT NULL制約と重複するため）
-            // const checkConstraintResult = await client.query(`...`);
-            // CHECK制約をCREATE TABLE内に追加は一時的に無効化
-            // for (const check of checkConstraintResult.rows) {
-            //   ddl += `,\n  CONSTRAINT ${check.constraint_name} CHECK ${check.check_clause}`;
-            // }
-            ddl += '\n);';
-            // 外部キー制約のみを別途生成
-            const foreignKeyResult = await client.query(`
-        SELECT 
-          tc.constraint_name,
-          kcu.column_name,
-          ccu.table_name AS foreign_table_name,
-          ccu.column_name AS foreign_column_name,
-          rc.delete_rule,
-          rc.update_rule
-        FROM information_schema.table_constraints tc
-        JOIN information_schema.key_column_usage kcu 
-          ON tc.constraint_name = kcu.constraint_name
-        JOIN information_schema.constraint_column_usage ccu 
-          ON ccu.constraint_name = tc.constraint_name
-        JOIN information_schema.referential_constraints rc 
-          ON tc.constraint_name = rc.constraint_name
-        WHERE tc.table_schema = 'public'
-          AND tc.table_name = $1
-          AND tc.constraint_type = 'FOREIGN KEY'
-        ORDER BY tc.constraint_name
-      `, [tableName]);
-            // 外部キー制約のみをALTER TABLE文として追加
-            for (const fk of foreignKeyResult.rows) {
-                ddl += `\n\nALTER TABLE ${tableName} ADD CONSTRAINT ${fk.constraint_name}`;
-                ddl += ` FOREIGN KEY (${fk.column_name})`;
-                ddl += ` REFERENCES ${fk.foreign_table_name} (${fk.foreign_column_name})`;
-                if (fk.delete_rule && fk.delete_rule !== 'NO ACTION') {
-                    ddl += ` ON DELETE ${fk.delete_rule}`;
-                }
-                if (fk.update_rule && fk.update_rule !== 'NO ACTION') {
-                    ddl += ` ON UPDATE ${fk.update_rule}`;
-                }
-                ddl += ';';
-            }
-            // インデックス情報を取得
-            const indexResult = await client.query(`
-        SELECT 
-          indexname,
-          indexdef
-        FROM pg_indexes 
-        WHERE schemaname = 'public' 
-          AND tablename = $1
-          AND indexname NOT LIKE '%_pkey'
-          AND indexname NOT IN (
-            SELECT tc.constraint_name 
-            FROM information_schema.table_constraints tc
-            WHERE tc.table_name = $1 AND tc.constraint_type = 'UNIQUE'
-          )
-        ORDER BY indexname
-      `, [tableName]);
-            // インデックスを追加
-            for (const idx of indexResult.rows) {
-                ddl += `\n\n${idx.indexdef};`;
-            }
-            // DDLを元の形式で保存
+            // DDL生成をdefinitionExtractorの関数で統一
+            const ddl = await (0, definitionExtractor_1.generateCreateTableDDL)(client, tableName, 'public');
             schemas[tableName] = {
                 ddl,
                 timestamp

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supatool",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "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",