supatool 0.1.23 → 0.3.1

package/dist/generator/typeGenerator.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypesFromModel = generateTypesFromModel;
+// TypeScript型定義自動生成（最小雛形）
+// 日本語コメント
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * モデルからTypeScript型定義ファイルを生成
+ * @param model モデルオブジェクト
+ * @param outPath 出力先パス
+ */
+function generateTypesFromModel(model, outPath) {
+    const dir = path_1.default.dirname(outPath);
+    if (!fs_1.default.existsSync(dir)) {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    let code = '// 自動生成: モデル型定義\n\n';
+    for (const m of model.models) {
+        const tables = m.tables || {};
+        for (const [tableName, table] of Object.entries(tables)) {
+            const t = table;
+            if (t.skipCreate)
+                continue;
+            code += `export type ${tableName} = {\n`;
+            for (const [colName, col] of Object.entries(t.fields || {})) {
+                const c = col;
+                code += `  ${colName}: ${toTsType(c.type)};\n`;
+            }
+            code += `}\n\n`;
+        }
+    }
+    fs_1.default.writeFileSync(outPath, code);
+}
+// 型変換ユーティリティ
+function toTsType(type) {
+    if (!type)
+        return 'any';
+    switch (type) {
+        case 'uuid':
+        case 'text':
+        case 'timestamp':
+            return 'string';
+        case 'int':
+        case 'integer':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        default:
+            return 'any';
+    }
+}

package/dist/generator/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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