supatool 0.3.5 → 0.3.6

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/package.json

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