supatool 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 IdeaGarage
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,105 @@
+# Supatool
+
+A CLI tool that automatically generates TypeScript CRUD code from Supabase type definitions.
+
+## Install
+
+```
+npm install -g supatool
+# or
+yarn global add supatool
+# or
+pnpm add -g supatool
+```
+
+## Usage
+
+1. Generate Supabase type definition file
+
+```
+npx supabase gen types typescript --project-id your_project_ref --schema public > shared/types.ts
+```
+
+2. Auto-generate CRUD code
+
+```
+supatool
+```
+- Output: `src/integrations/supabase/crud-autogen/`
+
+3. Subcommands
+
+See: [src/bin/helptext.ts](./src/bin/helptext.ts)
+
+For details on how to specify input/output folders, please refer to this as well.
+
+## VSCode/Cursor: Run Supabase CLI and supatool together
+
+You can add a task to `.vscode/tasks.json` to run both commands at once:
+
+```json
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Generate Supabase types and CRUD",
+      "type": "shell",
+      "command": "mkdir -p shared && npx supabase gen types typescript --project-id your_project_id --schema public > shared/types.ts && supatool crud --force",
+      "group": "build"
+    }
+  ]
+}
+```
+
+## Example: How to use generated CRUD code in your app
+
+CRUD utility files for the `apps` table will be generated in `src/integrations/supabase/crud-autogen/` by default.
+
+You can import and use these functions in your application as follows:
+
+```ts
+// Example: Using CRUD functions for the apps table
+import {
+  selectAppsRowsWithFilters,
+  selectAppsSingleRowWithFilters,
+  selectAppsRowById,
+  insertAppsRow,
+  updateAppsRow,
+  deleteAppsRow,
+} from 'src/integrations/supabase/crud-autogen/apps';
+
+// Get multiple rows with filters
+const apps = await selectAppsRowsWithFilters({ status: 'active' });
+
+// Get a single row with filters
+const app = await selectAppsSingleRowWithFilters({ id: 'your-app-id' });
+
+// Get by ID
+const appById = await selectAppsRowById('your-app-id');
+
+// Create new row
+const newApp = await insertAppsRow({ name: 'New App', status: 'active' });
+
+// Update row
+const updatedApp = await updateAppsRow({ id: 'your-app-id', name: 'Updated Name' });
+
+// Delete row
+const deletedApp = await deleteAppsRow('your-app-id');
+```
+
+- All functions are async and return the corresponding row type.
+- You can use filter objects for flexible queries.
+- See the generated file for each table in `src/integrations/supabase/crud-autogen/` for details.
+
+## Limitations
+
+Currently, the generated code only supports tables where the primary key column is named `id`.
+If your table's primary key is not named `id`, the `selectById`, `update`, and `delete` functions will not be generated for that table.
+
+## Repository
+
+For more details, see the project on GitHub: [https://github.com/idea-garage/supatool](https://github.com/idea-garage/supatool)
+
+## Acknowledgements
+
+This project is inspired by and made possible thanks to the amazing work of [Supabase](https://supabase.com/).

package/dist/bin/helptext.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpText = void 0;
+// See: [src/bin/helptext.ts](./src/bin/helptext.ts) from project root
+// Help text (command section from README, English only)
+exports.helpText = `
+Supatool CLI - Generate TypeScript CRUD code from Supabase type definitions
+
+Usage:
+  supatool crud [options]
+  supatool help
+
+Commands:
+  crud    Generate CRUD code
+  help    Show help
+
+Options:
+  -i, --import <path>   Import path for type definitions (default: shared/)
+  -e, --export <path>   Output path for CRUD code (default: src/integrations/supabase/)
+  -t, --tables <names>  Generate code for specific tables only (comma separated, e.g. table1,table2)
+  -f, --force           Overwrite output folder without confirmation
+  -h, --help            Show help
+  -V, --version         Show version
+
+Examples:
+  supatool crud
+    - Import path: shared/
+    - Export path: src/integrations/supabase/
+
+  supatool crud -i path/to/import -e path/to/export
+    - Import path: path/to/import
+    - Export path: path/to/export
+
+  supatool crud -t users,posts
+    - Only generate for users and posts tables
+`;

package/dist/bin/supatool.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// CLI entry point
+// Subcommand support with commander
+const commander_1 = require("commander");
+const index_1 = require("../index");
+const helptext_js_1 = require("./helptext.js"); // Import help text from external file
+const program = new commander_1.Command();
+program
+    .name('supatool')
+    .description('Supatool CLI')
+    .version('0.1.0');
+// crud subcommand
+program
+    .command('crud')
+    .description('Generate CRUD types')
+    .option('-i, --import <path>', 'Import path for type definitions', 'shared/')
+    .option('-e, --export <path>', 'Output path for CRUD code', 'src/integrations/supabase/')
+    .option('-t, --tables <tables>', 'Generate only for specific tables (comma separated)')
+    .option('-f, --force', 'Force overwrite output folder without confirmation')
+    .action((options) => {
+    // Reflect command line arguments to process.argv (for main() reuse)
+    const args = process.argv.slice(0, 2);
+    if (options.import) {
+        args.push('-i', options.import);
+    }
+    if (options.export) {
+        args.push('-e', options.export);
+    }
+    if (options.force) {
+        args.push('--force');
+    }
+    process.argv = args;
+    (0, index_1.main)();
+});
+// help subcommand
+program
+    .command('help')
+    .description('Show help')
+    .action(() => {
+    console.log(helptext_js_1.helpText);
+});
+// If no subcommand is specified, show helpText only (do not call main)
+if (!process.argv.slice(2).length) {
+    console.log(helptext_js_1.helpText);
+    process.exit(0);
+}
+program.parse(process.argv);

package/dist/index.js

@@ -0,0 +1,314 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-var-requires */
+// Generate TypeScript CRUD code from Supabase type definitions
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const typescript_1 = require("typescript");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+// Get paths from command line arguments (with default values)
+const args = process.argv.slice(2);
+let importPath = 'shared/';
+let exportPath = 'src/integrations/supabase/';
+let tables = null;
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === '-i' && args[i + 1]) {
+        importPath = args[i + 1];
+        i++;
+    }
+    else if (args[i] === '-e' && args[i + 1]) {
+        exportPath = args[i + 1];
+        i++;
+    }
+    else if ((args[i] === '--tables' || args[i] === '-t') && args[i + 1]) {
+        tables = args[i + 1].split(',').map((t) => t.trim());
+        i++;
+    }
+}
+// Convert to absolute paths
+const resolvedImportPath = path_1.default.resolve(process.cwd(), importPath);
+const resolvedExportPath = path_1.default.resolve(process.cwd(), exportPath);
+const typeDefinitionsPath = path_1.default.join(resolvedImportPath, 'types.ts');
+const crudFolderPath = path_1.default.join(resolvedExportPath, 'crud-autogen/');
+// Main process as a function
+function main() {
+    // Check --force option
+    const force = process.argv.includes('--force') || process.argv.includes('-f');
+    // Check if type definition file exists
+    if (!(0, fs_1.existsSync)(typeDefinitionsPath)) {
+        console.error(`Error: Type definition file not found: ${typeDefinitionsPath}`);
+        console.error('Please generate it with:');
+        console.error('  npx supabase gen types typescript --project-id "your-project-id" --schema public > shared/types.ts');
+        process.exit(1);
+    }
+    // Check if output folder exists
+    if ((0, fs_1.existsSync)(crudFolderPath) && !force) {
+        // Confirm via standard input
+        const readline = require('readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`Output folder already exists: ${crudFolderPath}\nOverwrite? (y/N): `, (answer) => {
+            rl.close();
+            if (answer.toLowerCase() !== 'y') {
+                console.log('Canceled.');
+                process.exit(0);
+            }
+            else {
+                generateCrud();
+            }
+        });
+        return;
+    }
+    generateCrud();
+    function generateCrud() {
+        // Read type definition file
+        const typeDefinitions = (0, fs_1.readFileSync)(typeDefinitionsPath, 'utf-8');
+        // Parse types using TypeScript parser
+        const sourceFile = (0, typescript_1.createSourceFile)(typeDefinitionsPath, typeDefinitions, typescript_1.ScriptTarget.Latest);
+        // Create program and get type checker
+        const program = (0, typescript_1.createProgram)([typeDefinitionsPath], {});
+        const typeChecker = program.getTypeChecker();
+        // Function to get schema name dynamically
+        const getSchemaName = (typeNode) => {
+            return typeNode.members.find((member) => member.name && member.name.text)
+                ?.name.text;
+        };
+        // Extract types (only Database type)
+        const types = sourceFile.statements
+            .filter(stmt => stmt.kind === typescript_1.SyntaxKind.TypeAliasDeclaration)
+            .flatMap(typeAliasDecl => {
+            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 [];
+                    });
+                }
+            }
+            return [];
+        });
+        // Show start of generation process
+        console.log(`Import path: ${importPath}`);
+        console.log(`Export path: ${exportPath}`);
+        // Create CRUD folder if it does not exist
+        if (!(0, fs_1.existsSync)(crudFolderPath)) {
+            (0, fs_1.mkdirSync)(crudFolderPath, { recursive: true });
+        }
+        // Generate CRUD code for each type
+        types
+            .filter(type => {
+            // If tables are specified, generate only for those table names
+            if (tables && tables.length > 0) {
+                return tables.includes(type.typeName);
+            }
+            return true;
+        })
+            .forEach(type => {
+            const fileName = toLowerCamelCase(type.typeName);
+            const crudCode = crudTemplate(type.typeName, type.fields, type.isView);
+            const filePath = crudFolderPath + `${fileName}.ts`;
+            // Show in console
+            if (type.isView) {
+                console.log(`Generating select operations only for view: ${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 });
+            }
+            (0, fs_1.writeFileSync)(filePath, crudCode);
+            console.log(`Generated ${fileName}.ts`);
+        });
+        console.log("CRUD operations have been generated.");
+    }
+}
+// Function to convert a string to lower camel case
+const toLowerCamelCase = (str) => {
+    return str.split('_').map((word, index) => index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join('');
+};
+// Function to convert a string to upper camel case
+const toUpperCamelCase = (str) => {
+    return str.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+};
+// 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 updateFunctionName = 'update' + upperCamelTypeName + 'Row';
+    const deleteFunctionName = 'delete' + upperCamelTypeName + 'Row';
+    const idType = fields.find((field) => field.name === 'id')?.type;
+    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
+async function ${selectByIdFunctionName}(id: ${idType}): Promise<${typeName} | ${typeName}[]> {
+    if (id !== undefined) {
+        const result = await supabase
+            .from('${typeName.toLowerCase()}')
+            .select('*')
+            .eq('id', id)
+            .single();
+        return result.data as ${typeName};
+    }
+    const result = await supabase.from('${typeName.toLowerCase()}').select('*');
+    return result.data as ${typeName}[];
+}
+`;
+    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
+async function ${selectFilteredRowsFunctionName}(filters: Filters = {}): Promise<${typeName}[]> {
+    let query = supabase.from('${typeName.toLowerCase()}').select('*');
+    query = applyFilters(query, filters);
+
+    const result = await query;
+    return result.data as ${typeName}[];
+}
+
+// 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();
+
+    const result = await query;
+    return result.data as unknown as ${typeName};
+}
+`;
+    const exportInsertOperation = isView ? '' :
+        `
+// Create Function
+async function ${insertFunctionName}(data: TablesInsert<'${typeName}'>): Promise<${typeName}> {
+    const result = await supabase
+        .from('${typeName}')
+        .insert([data])
+        .select()
+        .single();
+
+    if (result.data) {
+        return result.data as ${typeName};
+    }
+    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) {
+        return result.data as ${typeName};
+    }
+    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};
+    }
+    throw new Error('Failed to delete data');
+}
+`;
+    // Export all functions
+    const exportAll = `
+export { ${selectFilteredRowsFunctionName}, ${selectFilteredSingleRowFunctionName}${hasIdColumn ? ', ' + selectByIdFunctionName : ''}${isView ? '' : ', ' + insertFunctionName + ', ' + updateFunctionName + ', ' + deleteFunctionName} };
+`;
+    // Return all the code
+    return exportHeaders + exportSelectQueries + (hasIdColumn ? exportSelectById : '') + exportInsertOperation + exportUpdateOperation + exportDeleteOperation + exportAll;
+};
+// console.log(crudFolderPath);
+// console.log(types);

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "supatool",
+  "version": "0.1.0",
+  "description": "A CLI tool that automatically generates TypeScript CRUD code from Supabase type definitions.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "supatool": "dist/bin/supatool.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "tsx bin/supatool.ts"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "keywords": [
+    "supabase",
+    "crud",
+    "cli",
+    "typescript",
+    "React",
+    "postgres",
+    "database"
+  ],
+  "author": "IdeaGarage",
+  "license": "MIT",
+  "dependencies": {
+    "tsx": "^4.7.0",
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.30",
+    "commander": "^13.1.0"
+  }
+}