@creatorem/cli 0.0.1

package/bin/cli.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+/**
+ * Creatorem CLI
+ */
+
+import { runGenerateSchemas } from '../src/commands/generate-schemas.mjs';
+import { runGenerateMigration } from '../src/commands/generate-migration.mjs';
+import { showHelp } from '../src/commands/help.mjs';
+
+function main() {
+    const args = process.argv.slice(2);
+    
+    if (args.length === 0) {
+        showHelp();
+        process.exit(1);
+    }
+    
+    const command = args[0];
+    
+    switch (command) {
+        case 'generate-schemas':
+            runGenerateSchemas(args.slice(1));
+            break;
+        case 'generate-migration':
+            runGenerateMigration(args.slice(1));
+            break;
+        case 'help':
+        case '-h':
+        case '--help':
+            showHelp();
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            showHelp();
+            process.exit(1);
+    }
+}
+
+main();

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@creatorem/cli",
+  "version": "0.0.1",
+  "description": "CLI tool for Creatorem SaaS Kit",
+  "author": "Creatorem",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "creatorem": "./bin/cli.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "echo 'no build needed'"
+  }
+}

package/src/commands/generate-migration.mjs

@@ -0,0 +1,157 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { basename, join } from 'path';
+import { showHelp } from './help.mjs';
+
+export function runGenerateMigration(args) {
+    // Parse arguments specific to this command
+    let includeEnvSchemas = '';
+    let listEnvSchemas = false;
+    
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--app-schemas': {
+                const nextArg = args[i + 1];
+                if (i + 1 >= args.length || !nextArg || nextArg.startsWith('--')) {
+                    console.error('Error: --app-schemas requires a comma-separated list of schema names');
+                    console.error('Example: --app-schemas booking,other-schema');
+                    process.exit(1);
+                }
+                includeEnvSchemas = nextArg;
+                i++;
+                break;
+            }
+            case '--list-app-schemas':
+                listEnvSchemas = true;
+                break;
+            default:
+                console.error(`Unknown option: ${arg}`);
+                showHelp();
+                process.exit(1);
+        }
+    }
+
+    // Default paths based on CWD
+    const baseDir = process.cwd();
+    const supabaseDir = join(baseDir, 'supabase');
+    const envSchemasDir = join(supabaseDir, 'app-schemas');
+    const schemasDir = join(supabaseDir, 'schemas');
+    const migrationsDir = join(supabaseDir, 'migrations');
+
+    if (listEnvSchemas) {
+        console.log('Available environment schemas:');
+        if (existsSync(envSchemasDir)) {
+            const files = readdirSync(envSchemasDir).filter((file) => file.endsWith('.sql'));
+            files.forEach((file) => {
+                console.log(`  ${basename(file, '.sql')}`);
+            });
+        } else {
+            console.log('No app-schemas directory found at ' + envSchemasDir);
+        }
+        process.exit(0);
+    }
+
+    const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '').replace('T', '');
+    const migrationFile = join(migrationsDir, `${timestamp}_generated_from_schemas.sql`);
+
+    console.log('Generating migration file from schema files...');
+    if (includeEnvSchemas) {
+        console.log(`Environment schemas will be included: ${includeEnvSchemas}`);
+    }
+
+    // Create migrations directory if it doesn't exist
+    if (!existsSync(migrationsDir)) {
+        mkdirSync(migrationsDir, { recursive: true });
+    }
+
+    // Remove any existing generated migration
+    if (existsSync(migrationsDir)) {
+        const existingMigrations = readdirSync(migrationsDir).filter((file) => file.includes('_generated_from_schemas.sql'));
+        existingMigrations.forEach((file) => {
+            unlinkSync(join(migrationsDir, file));
+        });
+    }
+
+    // Automatically discover all SQL files in schemas directory and sort them
+    console.log(`Checking schemas directory: ${schemasDir}`);
+    let schemaFiles = [];
+    
+    if (existsSync(schemasDir)) {
+        schemaFiles = readdirSync(schemasDir)
+            .filter((file) => file.endsWith('.sql') && !file.startsWith('_') && file !== 'README.md')
+            .sort()
+            .map((file) => join(schemasDir, file));
+    } else {
+        console.warn(`Warning: schemas directory not found at ${schemasDir}`);
+    }
+
+    // Add environment schemas if specified
+    if (includeEnvSchemas) {
+        const envSchemas = includeEnvSchemas.split(',');
+
+        envSchemas.forEach((schema) => {
+            if (!existsSync(envSchemasDir)) {
+                console.warn(`Warning: app-schemas directory not found at ${envSchemasDir}`);
+                return;
+            }
+            
+            const envFiles = readdirSync(envSchemasDir)
+                .filter((file) => file.includes(schema) && file.endsWith('.sql'))
+                .sort()
+                .map((file) => join(envSchemasDir, file));
+
+            if (envFiles.length === 0) {
+                console.warn(`Warning: No environment schema files found for '${schema}'`);
+            } else {
+                schemaFiles.push(...envFiles);
+            }
+        });
+    }
+
+    // Check if any schema files were found
+    if (schemaFiles.length === 0) {
+        console.error('Error: No SQL schema files found');
+        process.exit(1);
+    }
+
+    console.log(`Found ${schemaFiles.length} schema files:`);
+    schemaFiles.forEach((file) => {
+        console.log(`  - ${basename(file)}`);
+    });
+    console.log('');
+
+    // Generate header comment
+    let header = `/*
+ * ---------------------------------------------------------------------------------
+ * Generated Migration from Schema Files
+ * ---------------------------------------------------------------------------------
+ * 
+ * This file is auto-generated from individual schema files.
+ * Do not edit this file directly - edit the source files in supabase/schemas/
+ * 
+ * Generated from schema files in dependency order:
+ `;
+
+    // Add the list of files to the header
+    schemaFiles.forEach((file) => {
+        header += ` * - ${basename(file)}\n`;
+    });
+
+    header += ' */\n\n';
+
+    // Combine all schema files
+    let content = header;
+    schemaFiles.forEach((file) => {
+        if (existsSync(file)) {
+            console.log(`Adding ${basename(file)}...`);
+            content += `${readFileSync(file, 'utf8')}\n\n`;
+        } else {
+            console.warn(`Warning: ${file} not found, skipping...`);
+        }
+    });
+
+    // Write the migration file
+    writeFileSync(migrationFile, content);
+
+    console.log(`Migration file generated: ${migrationFile}`);
+}

package/src/commands/generate-schemas.mjs

@@ -0,0 +1,159 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, copyFileSync, readdirSync, unlinkSync, statSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { validateSchema } from '../utils/validation.mjs';
+import { 
+    generateHeader, 
+    generateEnums, 
+    generateTable, 
+    generateComments, 
+    generatePermissions, 
+    generateRLS, 
+    generateTriggers 
+} from '../utils/sql-generator.mjs';
+
+export function runGenerateSchemas(args) {
+    // Logic from original generate-app-schemas.mjs
+
+    let data;
+    let inputDir;
+
+    let arg0 = 'cm-supabase'; // Default to looking for cm-supabase folder in cwd
+    if (args.length > 0) {
+        arg0 = args[0].trim();
+    }
+
+    try {
+        if (arg0.startsWith('{') || arg0.startsWith('[')) {
+            // Assume JSON string input
+            console.log("Parsing input as JSON string...");
+            data = JSON.parse(arg0);
+            inputDir = process.cwd(); // Default input dir for relative paths if needed
+        } else {
+            // Assume file or directory path
+            let inputPath = resolve(process.cwd(), arg0);
+            
+            if (!existsSync(inputPath)) {
+                console.error(`Error: Path not found at ${inputPath}`);
+                process.exit(1);
+            }
+            
+            const stats = statSync(inputPath);
+            if (stats.isDirectory()) {
+                // If directory, look for setup.json
+                inputPath = join(inputPath, 'setup.json');
+                if (!existsSync(inputPath)) {
+                     console.error(`Error: setup.json not found in directory ${args[0]} (defaults to setup.json if directory provided)`);
+                     process.exit(1);
+                }
+            }
+            
+            console.log(`Reading configuration from ${inputPath}...`);
+            const fileContent = readFileSync(inputPath, 'utf8');
+            data = JSON.parse(fileContent);
+            inputDir = dirname(inputPath);
+        }
+        
+        // Output dir: default to current dir/supabase/app-schemas logic
+        const defaultOutputDir = resolve(process.cwd(), 'supabase/app-schemas');
+        const outputDir = args[1] ? resolve(process.cwd(), args[1]) : defaultOutputDir;
+    
+        // ... validation ...
+        const schemaItems = validateSchema(data);
+    
+        if (!existsSync(outputDir)) {
+            mkdirSync(outputDir, { recursive: true });
+        } else {
+            // Clean existing files in output directory
+            console.log(`Cleaning output directory: ${outputDir}`);
+            if (existsSync(outputDir)) {
+                 const files = readdirSync(outputDir);
+                 for (const file of files) {
+                     const filePath = join(outputDir, file);
+                     if (statSync(filePath).isFile()) {
+                         unlinkSync(filePath);
+                     }
+                 }
+            }
+        }
+        
+        // Copy optional schemas
+        // inputDir is determined above
+        const extraSchemasDir = join(inputDir, 'schemas');
+        
+        if (existsSync(extraSchemasDir)) {
+            console.log(`Copying extra schemas from: ${extraSchemasDir}`);
+            const extraFiles = readdirSync(extraSchemasDir).filter(f => f.endsWith('.sql'));
+            
+            for (const file of extraFiles) {
+                const srcPath = join(extraSchemasDir, file);
+                const destPath = join(outputDir, file);
+                copyFileSync(srcPath, destPath);
+                console.log(`  Copied ${file}`);
+            }
+        }
+    
+        let fileCounter = 10;
+        
+        let pendingEnums = [];
+    
+        schemaItems.forEach((item) => {
+            if (item.enums) {
+                pendingEnums.push(...item.enums);
+            }
+            
+            if (item.table) {
+                const table = item.table;
+                const prefix = fileCounter.toString().padStart(3, '0');
+                const fileName = `${prefix}-${table.name}.sql`;
+                const filePath = join(outputDir, fileName);
+                
+                console.log(`Generating ${fileName}...`);
+                
+                // Determine dependencies
+                const dependencies = [];
+                
+                // Check for organization_id in common columns
+                if (table.commonColumns && table.commonColumns.includes('organization_id')) {
+                    dependencies.push('031-kit-org.sql (organizations table)');
+                }
+                
+                // Check for user_has_org_permission in RLS policies
+                let hasOrgPermissionShortcut = false;
+                if (table.rls && table.rls.policies) {
+                    for (const policy of table.rls.policies) {
+                        if (policy.conditions.some(c => c.includes('user_has_org_permission'))) {
+                            hasOrgPermissionShortcut = true;
+                            break;
+                        }
+                    }
+                }
+                
+                if (hasOrgPermissionShortcut) {
+                    dependencies.push('034-organization-members.sql (members table for organization access)');
+                }
+                
+                let fileContent = generateHeader(table.name, dependencies);
+                
+                if (pendingEnums.length > 0) {
+                    fileContent += generateEnums(pendingEnums);
+                    pendingEnums = []; // Clear after using
+                }
+                
+                fileContent += generateTable(table);
+                fileContent += generateComments(table);
+                fileContent += generatePermissions(table);
+                fileContent += generateRLS(table);
+                fileContent += generateTriggers(table);
+                
+                writeFileSync(filePath, fileContent);
+                fileCounter += 10;
+            }
+        });
+        
+        console.log("Success! Schemas generated.");
+    
+    } catch (e) {
+        console.error("Error processing schema:", e);
+        process.exit(1);
+    }
+}

package/src/commands/help.mjs

@@ -0,0 +1,20 @@
+export function showHelp() {
+    console.log(`
+Usage: creatorem <command> [options]
+
+Commands:
+  generate-schemas [input] [output]   Generate Supabase SQL schema files from JSON definition
+  generate-migration [options]        Generate a single migration file from schema files
+  help                                Show this help message
+
+Options (generate-migration):
+  --app-schemas <list>    Comma-separated list of schema names to include from app-schemas
+  --list-app-schemas      List available environment schemas
+
+Examples:
+  creatorem generate-schemas
+  creatorem generate-schemas apps/my-app/setup.json
+  creatorem generate-migration
+  creatorem generate-migration --app-schemas booking,orders
+`);
+}

package/src/utils/sql-generator.mjs

@@ -0,0 +1,183 @@
+export function generateHeader(name, dependencies = []) {
+    let depString = '';
+    if (dependencies.length > 0) {
+        depString = ` * Dependencies:\n${dependencies.map(d => ` * - ${d}`).join('\n')}`;
+    } else {
+        depString = ` * Dependencies: None`;
+    }
+
+    return `/*
+ * ---------------------------------------------------------------------------------
+ * ${name.charAt(0).toUpperCase() + name.slice(1)} Table Schema
+ * ---------------------------------------------------------------------------------
+ *
+ * Purpose: Store ${name} data for organizations
+ *
+ * Table of contents:
+ * - ${name.charAt(0).toUpperCase() + name.slice(1)} table
+ * - ${name.charAt(0).toUpperCase() + name.slice(1)} Comments
+ * - ${name.charAt(0).toUpperCase() + name.slice(1)} Permissions
+ * - ${name.charAt(0).toUpperCase() + name.slice(1)} RLS Policies
+ * - ${name.charAt(0).toUpperCase() + name.slice(1)} Triggers
+ *
+${depString}
+ */
+
+`;
+}
+
+export function generateEnums(enums) {
+    if (!enums || enums.length === 0) return '';
+    
+    let sql = `------------------------------------- ENUMS -------------------------------------\n\n`;
+    
+    enums.forEach(e => {
+        const values = e.values.map(v => `'${v}'`).join(', ');
+        sql += `/*\n * ${e.name.toUpperCase()} ENUM\n */\n`;
+        sql += `DO $$ BEGIN\n    CREATE TYPE ${e.name} AS ENUM (${values});\nEXCEPTION\n    WHEN duplicate_object THEN null;\nEND $$;\n\n`;
+    });
+    
+    return sql;
+}
+
+export function generateTable(table) {
+    let sql = `------------------------------------- ${table.name.toUpperCase()} TABLE -------------------------------------\n\n`;
+    sql += `/*\n * ${table.name.toUpperCase()} TABLE:\n * This table contains the ${table.name} data for organizations.\n */\n`;
+    sql += `CREATE TABLE IF NOT EXISTS "${table.schema}"."${table.name}" (\n`;
+
+    // Common columns
+    if (table.commonColumns && table.commonColumns.includes('id')) {
+        sql += `    id uuid unique not null default extensions.uuid_generate_v4(),\n`;
+    }
+    if (table.commonColumns && table.commonColumns.includes('organization_id')) {
+        sql += `    organization_id uuid references public.organization (id) on delete cascade not null,\n`;
+    }
+
+    // Custom columns
+    Object.entries(table.columns).forEach(([colName, colDef]) => {
+        let line = `    ${colName} ${colDef.type}`;
+        if (colDef.notNull) line += ` not null`;
+        if (colDef.default !== undefined) line += ` default '${colDef.default}'`; // Assuming string defaults for now, optimize if needed
+        if (colDef.check) line += ` check (${colDef.check})`;
+        
+        if (colDef.fk_ref) {
+            line += ` references ${colDef.fk_ref.table} (${colDef.fk_ref.column})`;
+            if (colDef.fk_ref.on_delete) {
+                line += ` on delete ${colDef.fk_ref.on_delete}`;
+            }
+        }
+        
+        sql += `${line},\n`;
+    });
+
+    // Common timestamps
+    if (table.commonColumns && table.commonColumns.includes('updated_at')) {
+        sql += `    updated_at timestamptz DEFAULT "now"() NOT NULL,\n`;
+    }
+    if (table.commonColumns && table.commonColumns.includes('created_at')) {
+        sql += `    created_at timestamptz DEFAULT "now"() NOT NULL,\n`;
+    }
+
+    sql += `    primary key (id)\n);\n\n`;
+
+    // Indexes (Basic: FKs usually need indexes)
+    // For every column that has fk_ref, add an index
+    Object.entries(table.columns).forEach(([colName, colDef]) => {
+         if (colDef.fk_ref || colName.endsWith('_id') || colName === 'status') {
+             sql += `CREATE INDEX IF NOT EXISTS idx_${table.name}_${colName} ON ${table.schema}.${table.name} (${colName});\n`;
+         }
+    });
+    sql += `\n`;
+
+    return sql;
+}
+
+export function generateComments(table) {
+    let sql = `------------------------------------- TABLE COMMENTS -------------------------------------\n\n`;
+    sql += `COMMENT ON TABLE "${table.schema}"."${table.name}" IS 'Allow to store ${table.name} data for organizations';\n`;
+    
+    Object.entries(table.columns).forEach(([colName, colDef]) => {
+        if (colDef.comment) {
+            sql += `COMMENT ON COLUMN "${table.schema}"."${table.name}"."${colName}" IS '${colDef.comment}';\n`;
+        }
+    });
+    sql += `\n`;
+    return sql;
+}
+
+export function generatePermissions(table) {
+    return `------------------------------------- PERMISSIONS -------------------------------------
+
+-- Reset the RLS access to authenticated and service_role roles
+REVOKE all on ${table.schema}.${table.name} from authenticated, service_role;
+GRANT select, insert, update, delete on table ${table.schema}.${table.name} to authenticated, service_role;
+
+-- Enable RLS on the ${table.name} table
+ALTER TABLE ${table.schema}.${table.name} ENABLE ROW LEVEL SECURITY;
+
+`;
+}
+
+export function expandCondition(condition) {
+    // Shortcuts expansion
+    // "user_has_org_permission('organization.manage')" 
+    // -> kit.user_is_member_of_org(organization_id) AND kit.has_org_permission(organization_id, 'organization.manage'::org_permission)
+    
+    if (condition.includes("user_has_org_permission")) {
+        // Regex to extract permission
+        const match = condition.match(/user_has_org_permission\('([^']+)'\)/);
+        if (match) {
+            const permission = match[1];
+            return `kit.user_is_member_of_org(organization_id) AND\n  kit.has_org_permission(organization_id, '${permission}'::org_permission)`;
+        }
+    }
+    return condition;
+}
+
+export function generateRLS(table) {
+    if (!table.rls || !table.rls.policies) return '';
+    
+    let sql = `------------------------------------- RLS POLICIES -------------------------------------\n\n`;
+    
+    table.rls.policies.forEach((policy, idx) => {
+        const policyName = `${table.name}_${policy.command.toLowerCase()}_${idx}`; // Simple naming, or just use command if unique
+        // Actually, user example uses "product_all"
+        const name = `${table.name}_${policy.command === 'ALL' ? 'all' : policy.command.toLowerCase()}${idx > 0 ? '_' + idx : ''}`;
+        
+        sql += `CREATE POLICY ${name} ON ${table.schema}.${table.name}\n`;
+        sql += `FOR ${policy.command} TO ${policy.roles.join(', ')}\n`;
+        
+        // Expanding conditions
+        const conditionsExpanded = policy.conditions.map(expandCondition).join(' AND\n  ');
+        
+        if (policy.command !== 'INSERT') {
+            sql += `USING (\n  ${conditionsExpanded}\n)`;
+        }
+        
+        if (policy.command === 'INSERT' || policy.command === 'ALL') {
+             if (policy.command === 'ALL') sql += `\nWITH CHECK (\n  ${conditionsExpanded}\n)`;
+             else sql += `WITH CHECK (\n  ${conditionsExpanded}\n)`;
+        }
+        
+        sql += `;\n\n`;
+    });
+    
+    return sql;
+}
+
+export function generateTriggers(table) {
+    // Check if updated_at exists
+    if (table.commonColumns && table.commonColumns.includes('updated_at')) {
+        return `------------------------------------- TRIGGERS -------------------------------------
+
+/*
+ * Trigger: Update timestamp on ${table.name} changes
+ * Automatically updates updated_at field when ${table.name} is modified
+ */
+create trigger reset_updated_at_on_${table.name}_on_update
+after update on ${table.schema}.${table.name} for each row
+execute procedure kit.reset_updated_at ();
+`;
+    }
+    return '';
+}

package/src/utils/validation.mjs

@@ -0,0 +1,81 @@
+/**
+ * @typedef {Object} FKRef
+ * @property {string} table
+ * @property {string} column
+ * @property {'cascade'|'restrict'|'set null'|'no action'} [on_delete]
+ */
+
+/**
+ * @typedef {Object} Column
+ * @property {string} type
+ * @property {boolean} [notNull]
+ * @property {string} [default]
+ * @property {string} [check]
+ * @property {string} [comment]
+ * @property {FKRef} [fk_ref]
+ */
+
+/**
+ * @typedef {Object} Policy
+ * @property {string} command - ALL, SELECT, INSERT, UPDATE, DELETE
+ * @property {string[]} roles
+ * @property {string[]} conditions
+ */
+
+/**
+ * @typedef {Object} Table
+ * @property {string} name
+ * @property {string} schema
+ * @property {string[]} commonColumns
+ * @property {Object.<string, Column>} columns
+ * @property {Object} rls
+ * @property {Policy[]} rls.policies
+ */
+
+/**
+ * @typedef {Object} Enum
+ * @property {string} name
+ * @property {string[]} values
+ */
+
+/**
+ * @typedef {Object} SchemaItem
+ * @property {Table} [table]
+ * @property {Enum[]} [enums]
+ */
+
+/**
+ * Validates the input JSON object against the expected schema.
+ * @param {any} p_data 
+ * @returns {SchemaItem[]}
+ */
+export function validateSchema(p_data) {
+    let items = p_data;
+    
+    // Handle new structure: { name: string, tables: [...] }
+    if (!Array.isArray(p_data) && p_data.tables && Array.isArray(p_data.tables)) {
+        items = p_data.tables;
+    } else if (!Array.isArray(p_data)) {
+        throw new Error("Root element must be an array or an object with a 'tables' array");
+    }
+
+    items.forEach((item, index) => {
+        if (item.table) {
+            const t = item.table;
+            if (!t.name) throw new Error(`Item ${index}: Table missing 'name'`);
+            if (!t.schema) throw new Error(`Item ${index}: Table missing 'schema'`);
+            if (!t.columns) throw new Error(`Item ${index}: Table missing 'columns'`);
+            // Basic structure check passed
+        } else if (item.enums) {
+            if (!Array.isArray(item.enums)) throw new Error(`Item ${index}: 'enums' must be an array`);
+            item.enums.forEach((e, eIdx) => {
+                if (!e.name) throw new Error(`Item ${index} Enum ${eIdx}: missing 'name'`);
+                if (!Array.isArray(e.values)) throw new Error(`Item ${index} Enum ${eIdx}: missing 'values' array`);
+            });
+        } else {
+            throw new Error(`Item ${index}: Must contain 'table' or 'enums'`);
+        }
+    });
+
+    return items;
+}