@objectql/cli 0.2.0

package/src/commands/generate.ts

@@ -0,0 +1,131 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import glob from 'fast-glob';
+import * as yaml from 'js-yaml';
+import { ObjectConfig, FieldConfig } from '@objectql/types';
+
+export async function generateTypes(sourceDir: string, outputDir: string) {
+    console.log(`Searching for objects in ${sourceDir}...`);
+    
+    const files = await glob(['**/*.object.yml', '**/*.object.yaml'], { 
+        cwd: sourceDir,
+        absolute: true,
+        ignore: ['**/node_modules/**'] 
+    });
+
+    if (files.length === 0) {
+        console.log('No object files found.');
+        return;
+    }
+
+    // Ensure output dir exists
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    const indexContent: string[] = [];
+
+    for (const file of files) {
+        const content = fs.readFileSync(file, 'utf8');
+        try {
+            const schema = yaml.load(content) as ObjectConfig;
+            if (!schema || !schema.name) continue;
+
+            const typeName = toPascalCase(schema.name);
+            const typeDefinition = generateInterface(typeName, schema);
+            
+            const outPath = path.join(outputDir, `${schema.name}.ts`);
+            fs.writeFileSync(outPath, typeDefinition);
+            console.log(`Generated ${schema.name}.ts`);
+
+            indexContent.push(`export * from './${schema.name}';`);
+        } catch (e) {
+            console.error(`Failed to parse ${file}:`, e);
+        }
+    }
+
+    // Generate index.ts
+    fs.writeFileSync(path.join(outputDir, 'index.ts'), indexContent.join('\n'));
+    console.log(`Generated types in ${outputDir}`);
+}
+
+function generateInterface(typeName: string, schema: ObjectConfig): string {
+    const fields = schema.fields || {};
+    const lines = [
+        `// Auto-generated by ObjectQL. DO NOT EDIT.`,
+        `import { ObjectDoc } from '@objectql/types';`, // Assuming a base type exists or we define it
+        ``,
+        `export interface ${typeName} extends ObjectDoc {`
+    ];
+
+    for (const [key, field] of Object.entries(fields)) {
+        const fieldName = field.name || key;
+        const isOptional = !field.required;
+        const tsType = mapFieldTypeToTs(field);
+        
+        // Add JSDoc
+        if (field.label || field.description) {
+            lines.push(`    /**`);
+            if (field.label) lines.push(`     * ${field.label}`);
+            if (field.description) lines.push(`     * ${field.description}`);
+            lines.push(`     */`);
+        }
+        
+        lines.push(`    ${fieldName}${isOptional ? '?' : ''}: ${tsType};`);
+    }
+
+    lines.push(`}`);
+    lines.push(``);
+    return lines.join('\n');
+}
+
+function mapFieldTypeToTs(field: FieldConfig): string {
+    switch (field.type) {
+        case 'text':
+        case 'textarea':
+        case 'markdown':
+        case 'html':
+        case 'email':
+        case 'phone':
+        case 'url':
+        case 'password':
+        case 'select': // Could be stricter if options are strings
+            return 'string';
+        
+        case 'number':
+        case 'currency':
+        case 'percent':
+        case 'auto_number':
+            return 'number';
+        
+        case 'boolean':
+            return 'boolean';
+            
+        case 'date':
+        case 'datetime':
+        case 'time':
+            return 'Date | string';
+            
+        case 'vector':
+            return 'number[]';
+            
+        case 'file':
+        case 'image':
+            return field.multiple ? 'any[]' : 'any'; // Simplified for now
+            
+        case 'object':
+        case 'location':
+            return 'any';
+
+        case 'lookup':
+        case 'master_detail':
+            return 'string | number'; // The ID
+
+        default:
+            return 'any';
+    }
+}
+
+function toPascalCase(str: string): string {
+    return str.replace(/(^\w|_\w)/g, m => m.replace('_', '').toUpperCase());
+}

package/src/commands/repl.ts

@@ -0,0 +1,120 @@
+import * as repl from 'repl';
+import * as path from 'path';
+import * as fs from 'fs';
+import { ObjectQL } from '@objectql/core';
+import { register } from 'ts-node';
+
+export async function startRepl(configPath?: string) {
+    const cwd = process.cwd();
+    
+    // Register ts-node to handle TS config loading
+    register({
+        transpileOnly: true,
+        compilerOptions: {
+            module: "commonjs"
+        }
+    });
+
+    // 1. Resolve Config File
+    let configFile = configPath;
+    if (!configFile) {
+        const potentialFiles = ['objectql.config.ts', 'objectql.config.js'];
+        for (const file of potentialFiles) {
+            if (fs.existsSync(path.join(cwd, file))) {
+                configFile = file;
+                break;
+            }
+        }
+    }
+
+    if (!configFile) {
+        console.error("❌ No configuration file found (objectql.config.ts/js).");
+        console.log("Please create one that exports an ObjectQL instance.");
+        process.exit(1);
+    }
+
+    console.log(`🚀 Loading configuration from ${configFile}...`);
+    
+    try {
+        const configModule = require(path.join(cwd, configFile));
+        // Support default export or named export 'app' or 'objectql' or 'db'
+        const app = configModule.default || configModule.app || configModule.objectql || configModule.db;
+
+        if (!(app instanceof ObjectQL)) {
+            console.error("❌ The config file must export an instance of 'ObjectQL' as default or 'app'/'db'.");
+            process.exit(1);
+        }
+
+        // 2. Init ObjectQL
+        await app.init();
+        console.log("✅ ObjectQL Initialized.");
+
+        // 3. Start REPL
+        const r = repl.start({
+            prompt: 'objectql> ',
+            useColors: true
+        });
+
+        // Enable Auto-Await for Promises
+        const defaultEval = r.eval;
+        (r as any).eval = (cmd: string, context: any, filename: string, callback: any) => {
+            defaultEval.call(r, cmd, context, filename, async (err: Error | null, result: any) => {
+                if (err) return callback(err, null);
+                if (result && typeof result.then === 'function') {
+                    try {
+                        const value = await result;
+                        callback(null, value);
+                    } catch (e: any) {
+                        callback(e, null);
+                    }
+                } else {
+                    callback(null, result);
+                }
+            });
+        };
+
+        // 4. Inject Context
+        r.context.app = app;
+        r.context.db = app; // Alias for db
+        r.context.object = (name: string) => app.getObject(name);
+        
+        // Helper to get a repo quickly: tasks.find() instead of app.object('tasks').find()
+        const objects = app.metadata.list('object');
+        for (const obj of objects) {
+            // Inject repositories as top-level globals if valid identifiers
+            if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(obj.name)) {
+                // We use a getter to lazily create context with system privileges
+                Object.defineProperty(r.context, obj.name, {
+                    get: () => {
+                        // HACK: We need to construct a repository. 
+                        // Since `ObjectRepository` is exported from `@objectql/core`, we can use it if we import it.
+                        // But `app` is passed from user land. We can rely on `require('@objectql/core')` here.
+                        const { ObjectRepository } = require('@objectql/core');
+                        
+                        const replContext: any = {
+                            roles: ['admin'],
+                            isSystem: true,
+                            userId: 'REPL'
+                        };
+                        
+                        replContext.object = (n: string) => new ObjectRepository(n, replContext, app);
+                        replContext.transaction = async (cb: any) => cb(replContext);
+                        replContext.sudo = () => replContext;
+
+                        return new ObjectRepository(obj.name, replContext, app);
+                    }
+                });
+            }
+        }
+
+        console.log(`\nAvailable Objects: ${objects.map((o: any) => o.name).join(', ')}`);
+        console.log(`Usage: tasks.find()  (Auto-await enabled)`);
+        
+        // Fix for REPL sometimes not showing prompt immediately
+        r.displayPrompt();
+
+    } catch (error) {
+        console.error("Failed to load or start:", error);
+        process.exit(1);
+    }
+}

package/src/commands/serve.ts

@@ -0,0 +1,94 @@
+import { ObjectQL } from '@objectql/core';
+import { KnexDriver } from '@objectql/driver-knex';
+import { createNodeHandler } from '@objectql/server';
+import { createServer } from 'http';
+import * as path from 'path';
+import chalk from 'chalk';
+
+const CONSOLE_HTML = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>ObjectQL Swagger UI</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui.css" />
+  <style>
+    body { margin: 0; padding: 0; }
+  </style>
+</head>
+<body>
+<div id="swagger-ui"></div>
+<script src="https://unpkg.com/swagger-ui-dist@5.11.0/swagger-ui-bundle.js" crossorigin></script>
+<script>
+  window.onload = () => {
+    window.ui = SwaggerUIBundle({
+      url: '/openapi.json',
+      dom_id: '#swagger-ui',
+    });
+  };
+</script>
+</body>
+</html>
+`;
+
+export async function serve(options: { port: number; dir: string }) {
+    console.log(chalk.blue('Starting ObjectQL Dev Server...'));
+    
+    const rootDir = path.resolve(process.cwd(), options.dir);
+    console.log(chalk.gray(`Loading schema from: ${rootDir}`));
+
+    // 1. Init ObjectQL with in-memory SQLite for Dev
+    const app = new ObjectQL({
+        datasources: {
+            default: new KnexDriver({
+                client: 'sqlite3',
+                connection: {
+                    filename: ':memory:' // Or local file './dev.db'
+                },
+                useNullAsDefault: true
+            })
+        }
+    });
+
+    // 2. Load Schema
+    try {
+        app.loadFromDirectory(rootDir);
+        await app.init();
+        console.log(chalk.green('✅ Schema loaded successfully.'));
+    } catch (e: any) {
+        console.error(chalk.red('❌ Failed to load schema:'), e.message);
+        process.exit(1);
+    }
+
+    // 3. Create Handler
+    const internalHandler = createNodeHandler(app);
+
+    // 4. Start Server
+    const server = createServer(async (req, res) => {
+        // Serve Swagger UI
+        if (req.method === 'GET' && (req.url === '/swagger' || req.url === '/swagger/')) {
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(CONSOLE_HTML);
+            return;
+        }
+
+        // Redirect / to /swagger for better DX
+        if (req.method === 'GET' && req.url === '/') {
+            res.writeHead(302, { 'Location': '/swagger' });
+            res.end();
+            return;
+        }
+
+        // Delegate to API Handler
+        await internalHandler(req, res);
+    });
+    
+    server.listen(options.port, () => {
+        console.log(chalk.green(`\n🚀 Server ready at http://localhost:${options.port}`));
+        console.log(chalk.green(`📚 Swagger UI:   http://localhost:${options.port}/swagger`));
+        console.log(chalk.blue(`📖 OpenAPI Spec:  http://localhost:${options.port}/openapi.json`));
+        console.log(chalk.gray('\nTry a curl command:'));
+        console.log(`curl -X POST http://localhost:${options.port} -H "Content-Type: application/json" -d '{"op": "find", "object": "YourObject", "args": {}}'`);
+    });
+}

package/src/index.ts

@@ -0,0 +1,47 @@
+import { Command } from 'commander';
+import { generateTypes } from './commands/generate';
+import { startRepl } from './commands/repl';
+import { serve } from './commands/serve';
+
+const program = new Command();
+
+program
+  .name('objectql')
+  .description('ObjectQL CLI tool')
+  .version('0.1.0');
+
+program
+    .command('generate')
+    .alias('g')
+    .description('Generate TypeScript interfaces from ObjectQL schema files')
+    .option('-s, --source <path>', 'Source directory containing *.object.yml', '.')
+    .option('-o, --output <path>', 'Output directory for generated types', './src/generated')
+    .action(async (options) => {
+        try {
+            await generateTypes(options.source, options.output);
+        } catch (error) {
+            console.error(error);
+            process.exit(1);
+        }
+    });
+
+program
+    .command('repl')
+    .alias('r')
+    .description('Start an interactive shell (REPL) to query the database')
+    .option('-c, --config <path>', 'Path to objectql.config.ts/js')
+    .action(async (options) => {
+        await startRepl(options.config);
+    });
+
+program
+    .command('serve')
+    .alias('s')
+    .description('Start a development server')
+    .option('-p, --port <number>', 'Port to listen on', '3000')
+    .option('-d, --dir <path>', 'Directory containing schema', '.')
+    .action(async (options) => {
+        await serve({ port: parseInt(options.port), dir: options.dir });
+    });
+
+program.parse();

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}