naidejs 1.0.0 → 1.2.0

package/src/generator.js

@@ -1,13 +1,43 @@
 export class Generator {
-  constructor() {
+  constructor(options = {}) {
     this.indent = 0;
     this.output = [];
     this.usesExpress = false;
     this.models = new Map();
+    this.runtimeImports = new Set();
+    this.schemas = new Map();
+    this.needsEventBus = false;
+    this.runtimePath = options.runtimePath || 'naidejs/runtime';
+    this.dbDir = null;
+    this.authSecret = null;
+    this.hasWs = false;
+    this.wsNodes = [];
   }
 
   generate(ast) {
     this.visitProgram(ast);
+
+    const preamble = [];
+
+    if (this.needsEventBus) {
+      this.runtimeImports.add('createEventBus');
+    }
+
+    if (this.runtimeImports.size > 0) {
+      const imports = [...this.runtimeImports].join(', ');
+      preamble.push(`import { ${imports} } from '${this.runtimePath}';`);
+      preamble.push('');
+    }
+
+    if (this.needsEventBus) {
+      preamble.push('const __eventBus = createEventBus();');
+      preamble.push('');
+    }
+
+    if (preamble.length > 0) {
+      this.output.unshift(...preamble);
+    }
+
     return this.output.join('\n');
   }
 
@@ -32,6 +62,7 @@ export class Generator {
       case 'Function': return this.visitFunction(node);
       case 'Return': return this.visitReturn(node);
       case 'ReturnStatus': return this.visitReturnStatus(node);
+      case 'ReturnMethod': return this.visitReturnMethod(node);
       case 'TypedVar': return this.visitTypedVar(node);
       case 'If': return this.visitIf(node);
       case 'Each': return this.visitEach(node);
@@ -50,7 +81,21 @@ export class Generator {
       case 'CompoundAssign': return this.visitCompoundAssign(node);
       case 'ExprStatement': this.emit(this.expr(node.expression) + ';'); return;
       case 'DbConnect': return this.visitDbConnect(node);
+      case 'DbDir': return this.visitDbDir(node);
       case 'AwaitAll': return this.visitAwaitAllStatement(node);
+      case 'SchemaDecl': return this.visitSchema(node);
+      case 'CrudDecl': return this.visitCrudTopLevel(node);
+      case 'AuthDecl': return this.visitAuthTopLevel(node);
+      case 'CorsDecl': return this.visitCorsTopLevel(node);
+      case 'LimitDecl': return this.visitLimitTopLevel(node);
+      case 'EnvDecl': return this.visitEnv(node);
+      case 'EveryDecl': return this.visitEvery(node);
+      case 'WatchDecl': return this.visitWatch(node);
+      case 'StaticDecl': return this.visitStaticTopLevel(node);
+      case 'WsDecl': return this.visitWsTopLevel(node);
+      case 'GroupDecl': return this.visitGroupTopLevel(node);
+      case 'ErrorHandler': return this.visitErrorHandlerTopLevel(node);
+      case 'CookieDecl': return this.visitCookieTopLevel(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -101,6 +146,26 @@ export class Generator {
     this.emit(`return res.status(${this.expr(node.statusCode)}).json(${this.expr(node.body)});`);
   }
 
+  visitReturnMethod(node) {
+    const val = this.expr(node.value);
+    switch (node.method) {
+      case 'redirect':
+        this.emit(`return res.redirect(${val});`);
+        break;
+      case 'html':
+        this.emit(`return res.type('html').send(${val});`);
+        break;
+      case 'text':
+        this.emit(`return res.type('text').send(${val});`);
+        break;
+      case 'file':
+        this.emit(`return res.sendFile(${val});`);
+        break;
+      default:
+        this.emit(`return res.${node.method}(${val});`);
+    }
+  }
+
   visitTypedVar(node) {
     const keyword = node.isMut ? 'let' : 'const';
     const exp = node.isPublic ? 'export ' : '';
@@ -111,7 +176,6 @@ export class Generator {
     const target = this.expr(node.target);
     const value = this.expr(node.value);
 
-    // Destructuring assignment
     if (node.target.type === 'Array') {
       const names = node.target.elements.map(e => this.expr(e)).join(', ');
       this.emit(`const [${names}] = ${value};`);
@@ -219,35 +283,72 @@ export class Generator {
   }
 
   visitServer(node) {
+    const hasWs = node.routes.some(r => r.type === 'WsDecl');
+
     this.emit(`import express from 'express';`);
+    if (hasWs) {
+      this.emit(`import { WebSocketServer } from 'ws';`);
+    }
     this.emitRaw('');
     this.emit(`const ${node.name} = express();`);
     this.emit(`${node.name}.use(express.json());`);
+    this.emit(`${node.name}.use(express.urlencoded({ extended: true }));`);
     this.emitRaw('');
 
-    // Middleware
     for (const mid of node.middleware) {
       this.emit(`${node.name}.use(${this.generateMiddleware(mid)});`);
       this.emitRaw('');
     }
 
-    // Routes
-    for (const route of node.routes) {
-      if (route.type === 'Route') {
-        this.visitRoute(node.name, route);
+    const wsNodes = [];
+    const errorHandlers = [];
+
+    for (const child of node.routes) {
+      if (child.type === 'Route') {
+        this.visitRoute(node.name, child);
+      } else if (child.type === 'CrudDecl') {
+        this.visitCrud(node.name, child);
+      } else if (child.type === 'AuthDecl') {
+        this.visitAuth(node.name, child);
+      } else if (child.type === 'CorsDecl') {
+        this.visitCors(node.name, child);
+      } else if (child.type === 'LimitDecl') {
+        this.visitLimit(node.name, child);
+      } else if (child.type === 'StaticDecl') {
+        this.visitStatic(node.name, child);
+      } else if (child.type === 'WsDecl') {
+        wsNodes.push(child);
+      } else if (child.type === 'GroupDecl') {
+        this.visitGroup(node.name, child);
+      } else if (child.type === 'ErrorHandler') {
+        errorHandlers.push(child);
+      } else if (child.type === 'CookieDecl') {
+        this.visitCookie(node.name, child);
       } else {
-        this.visitStatement(route);
+        this.visitStatement(child);
       }
     }
 
-    // Listen
+    for (const eh of errorHandlers) {
+      this.visitErrorHandler(node.name, eh);
+    }
+
     const port = node.port ? this.expr(node.port) : '3000';
     this.emitRaw('');
-    this.emit(`${node.name}.listen(${port}, () => {`);
+    if (hasWs) {
+      this.emit(`const __server = ${node.name}.listen(${port}, () => {`);
+    } else {
+      this.emit(`${node.name}.listen(${port}, () => {`);
+    }
     this.indent++;
     this.emit(`console.log(\`Server running on port \${${port}}\`);`);
     this.indent--;
     this.emit('});');
+
+    for (const wsNode of wsNodes) {
+      this.emitRaw('');
+      this.visitWs(wsNode);
+    }
   }
 
   visitRoute(appName, route) {
@@ -255,17 +356,14 @@ export class Generator {
     const path = this.stringValue(route.path);
     const params = route.params.length > 0 ? route.params.join(', ') : 'req, res';
 
-    // Check if body uses await
     const needsAsync = this.bodyUsesAwait(route.body);
     const asyncPrefix = needsAsync ? 'async ' : '';
 
     this.emit(`${appName}.${method}(${path}, ${asyncPrefix}(${params}) => {`);
     this.indent++;
 
-    // If params don't include res, inject it
     const hasRes = params.includes('res');
 
-    // Transform body: last expression with ret becomes res.json
     for (let i = 0; i < route.body.length; i++) {
       const stmt = route.body[i];
       if (stmt.type === 'Return' && stmt.value !== null) {
@@ -326,7 +424,6 @@ export class Generator {
       this.emitRaw('');
     }
 
-    // Methods
     for (const method of node.methods) {
       const async = method.isAsync ? 'async ' : '';
       const params = method.params.map(p => {
@@ -353,8 +450,6 @@ export class Generator {
 
   visitOn(node) {
     const event = this.expr(node.event);
-    // Split event into object and event name
-    // e.g., process.exit -> process.on('exit', ...)
     if (node.event.type === 'MemberAccess') {
       const obj = this.expr(node.event.object);
       const evt = node.event.property;
@@ -376,7 +471,6 @@ export class Generator {
 
   visitThrow(node) {
     const value = this.expr(node.value);
-    // If it's a string, wrap in Error
     if (node.value.type === 'String') {
       this.emit(`throw new Error(${value});`);
     } else {
@@ -388,12 +482,348 @@ export class Generator {
     this.emit(`const db = new Database(${this.expr(node.connectionString)});`);
   }
 
+  visitDbDir(node) {
+    const raw = node.path.raw || node.path.parts?.map(p => p.value).join('') || 'data/';
+    this.dbDir = raw.endsWith('/') ? raw : raw + '/';
+  }
+
   visitAwaitAllStatement(node) {
     const exprs = node.expressions.map(e => this.expr(e)).join(', ');
     this.emit(`await Promise.all([${exprs}]);`);
   }
 
-  // Expression generation
+  // ===== High-level features =====
+
+  visitSchema(node) {
+    this.runtimeImports.add('createSchema');
+    if (this.dbDir) {
+      this.runtimeImports.add('createFileStore');
+    } else {
+      this.runtimeImports.add('createStore');
+    }
+
+    this.emit(`const ${node.name}Schema = createSchema('${node.name}', {`);
+    this.indent++;
+
+    for (const field of node.fields) {
+      const props = [];
+
+      switch (field.type) {
+        case 'auto':
+          props.push("type: 'id'", 'auto: true');
+          break;
+        case 'timestamp':
+          props.push("type: 'timestamp'");
+          break;
+        case 'str':
+          props.push("type: 'string'");
+          break;
+        case 'int':
+          props.push("type: 'integer'");
+          break;
+        case 'num':
+          props.push("type: 'number'");
+          break;
+        case 'bool':
+          props.push("type: 'boolean'");
+          break;
+        case 'enum':
+          if (field.enumValues) {
+            const vals = field.enumValues.map(v => this.expr(v)).join(', ');
+            props.push("type: 'enum'", `values: [${vals}]`);
+          } else {
+            props.push("type: 'enum'");
+          }
+          break;
+        default:
+          props.push(`type: '${field.type}'`);
+          break;
+      }
+
+      for (const mod of field.modifiers) {
+        switch (mod.name) {
+          case 'required': props.push('required: true'); break;
+          case 'optional': props.push('required: false'); break;
+          case 'unique': props.push('unique: true'); break;
+          case 'email': props.push('email: true'); break;
+          case 'url': props.push('url: true'); break;
+          case 'auto': props.push('auto: true'); break;
+          case 'min': props.push(`min: ${this.expr(mod.args[0])}`); break;
+          case 'max': props.push(`max: ${this.expr(mod.args[0])}`); break;
+          case 'default': props.push(`default: ${this.expr(mod.args[0])}`); break;
+        }
+      }
+
+      this.emit(`${field.name}: { ${props.join(', ')} },`);
+    }
+
+    this.indent--;
+    this.emit('});');
+    if (this.dbDir) {
+      this.emit(`const ${node.name}Store = createFileStore(${node.name}Schema, '${this.dbDir}${node.name}.json');`);
+    } else {
+      this.emit(`const ${node.name}Store = createStore(${node.name}Schema);`);
+    }
+    this.emitRaw('');
+
+    this.schemas.set(node.name, node);
+  }
+
+  visitCrud(appName, node) {
+    this.runtimeImports.add('registerCrud');
+    this.needsEventBus = true;
+
+    const path = this.stringValue(node.path);
+    this.emit(`registerCrud(${appName}, ${path}, ${node.schemaName}Schema, ${node.schemaName}Store, __eventBus);`);
+    this.emitRaw('');
+  }
+
+  visitCrudTopLevel(node) {
+    this.visitCrud('app', node);
+  }
+
+  visitAuth(appName, node) {
+    this.runtimeImports.add('jwtAuth');
+
+    const secret = this.expr(node.secret);
+    this.authSecret = secret;
+
+    this.emit(`const __authSecret = ${secret};`);
+
+    const options = [];
+    if (node.publicPaths.length > 0) {
+      const paths = node.publicPaths.map(p => this.stringValue(p)).join(', ');
+      options.push(`public: [${paths}]`);
+    }
+    const optStr = options.length > 0 ? `, { ${options.join(', ')} }` : '';
+
+    if (node.protectedPaths.length > 0) {
+      const path = this.stringValue(node.protectedPaths[0]);
+      this.emit(`${appName}.use(${path}, jwtAuth(${secret}${optStr}));`);
+    } else {
+      this.emit(`${appName}.use(jwtAuth(${secret}${optStr}));`);
+    }
+    this.emitRaw('');
+  }
+
+  visitAuthTopLevel(node) {
+    this.visitAuth('app', node);
+  }
+
+  visitCors(appName, node) {
+    this.runtimeImports.add('corsMiddleware');
+
+    const origins = this.expr(node.origins);
+    if (node.origins.type === 'String') {
+      this.emit(`${appName}.use(corsMiddleware([${origins}]));`);
+    } else {
+      this.emit(`${appName}.use(corsMiddleware(${origins}));`);
+    }
+    this.emitRaw('');
+  }
+
+  visitCorsTopLevel(node) {
+    this.visitCors('app', node);
+  }
+
+  visitLimit(appName, node) {
+    this.runtimeImports.add('rateLimit');
+
+    const path = this.stringValue(node.path);
+    const max = this.expr(node.max);
+    const window = this.expr(node.window);
+    this.emit(`${appName}.use(${path}, rateLimit(${max}, ${window}));`);
+    this.emitRaw('');
+  }
+
+  visitLimitTopLevel(node) {
+    this.visitLimit('app', node);
+  }
+
+  visitStatic(appName, node) {
+    let raw = node.path.raw || node.path.parts?.map(p => p.value).join('') || 'public';
+    if (raw.startsWith('/')) raw = raw.slice(1);
+    this.emit(`${appName}.use(express.static(${JSON.stringify(raw)}));`);
+    this.emitRaw('');
+  }
+
+  visitStaticTopLevel(node) {
+    this.visitStatic('app', node);
+  }
+
+  visitWs(node) {
+    const path = this.stringValue(node.path);
+    this.emit(`const __wss = new WebSocketServer({ server: __server, path: ${path} });`);
+    this.emit(`__wss.on('connection', (__ws) => {`);
+    this.indent++;
+    this.emit(`const send = (d) => __ws.send(typeof d === 'string' ? d : JSON.stringify(d));`);
+    this.emit(`const broadcast = (d) => { const m = typeof d === 'string' ? d : JSON.stringify(d); for (const c of __wss.clients) if (c.readyState === 1) c.send(m); };`);
+
+    const connectEvents = node.events.filter(e => {
+      const name = e.name.raw || e.name.parts?.map(p => p.value).join('');
+      return name === 'connect' || name === 'open';
+    });
+    const otherEvents = node.events.filter(e => {
+      const name = e.name.raw || e.name.parts?.map(p => p.value).join('');
+      return name !== 'connect' && name !== 'open';
+    });
+
+    for (const evt of connectEvents) {
+      this.emitRaw('');
+      for (const stmt of evt.body) this.visitStatement(stmt);
+    }
+
+    for (const evt of otherEvents) {
+      const evtName = evt.name.raw || evt.name.parts?.map(p => p.value).join('');
+      this.emitRaw('');
+
+      if (evtName === 'message') {
+        const needsAsync = this.bodyUsesAwait(evt.body);
+        const asyncPrefix = needsAsync ? 'async ' : '';
+        this.emit(`__ws.on('message', ${asyncPrefix}(__raw) => {`);
+        this.indent++;
+        const dataParam = evt.params[0] || 'data';
+        this.emit(`const ${dataParam} = JSON.parse(__raw);`);
+        for (const stmt of evt.body) this.visitStatement(stmt);
+        this.indent--;
+        this.emit('});');
+      } else {
+        const params = evt.params.length > 0 ? evt.params.join(', ') : '';
+        const needsAsync = this.bodyUsesAwait(evt.body);
+        const asyncPrefix = needsAsync ? 'async ' : '';
+        this.emit(`__ws.on('${evtName}', ${asyncPrefix}(${params}) => {`);
+        this.indent++;
+        for (const stmt of evt.body) this.visitStatement(stmt);
+        this.indent--;
+        this.emit('});');
+      }
+    }
+
+    this.indent--;
+    this.emit('});');
+  }
+
+  visitWsTopLevel(node) {
+    this.visitWs(node);
+  }
+
+  visitGroup(appName, node) {
+    const prefix = this.stringValue(node.prefix);
+    this.groupCounter = (this.groupCounter || 0) + 1;
+    const routerName = `__router${this.groupCounter}`;
+    this.emit(`const ${routerName} = express.Router();`);
+
+    for (const child of node.routes) {
+      if (child.type === 'Route') {
+        this.visitRoute(routerName, child);
+      } else if (child.type === 'CrudDecl') {
+        this.visitCrud(routerName, child);
+      } else if (child.type === 'AuthDecl') {
+        this.visitAuth(routerName, child);
+      } else if (child.type === 'GroupDecl') {
+        this.visitGroup(routerName, child);
+      } else {
+        this.visitStatement(child);
+      }
+    }
+
+    this.emit(`${appName}.use(${prefix}, ${routerName});`);
+    this.emitRaw('');
+  }
+
+  visitGroupTopLevel(node) {
+    this.visitGroup('app', node);
+  }
+
+  visitErrorHandler(appName, node) {
+    const params = node.params.join(', ');
+    this.emit(`${appName}.use((${params}, next) => {`);
+    this.indent++;
+    for (const stmt of node.body) this.visitStatement(stmt);
+    this.indent--;
+    this.emit('});');
+    this.emitRaw('');
+  }
+
+  visitErrorHandlerTopLevel(node) {
+    this.visitErrorHandler('app', node);
+  }
+
+  visitCookie(appName, node) {
+    this.runtimeImports.add('cookieParser');
+    this.emit(`${appName}.use(cookieParser());`);
+    this.emitRaw('');
+  }
+
+  visitCookieTopLevel(node) {
+    this.visitCookie('app', node);
+  }
+
+  visitEnv(node) {
+    this.runtimeImports.add('loadEnv');
+
+    const names = node.vars.map(v => v.name);
+    this.emit(`const { ${names.join(', ')} } = loadEnv({`);
+    this.indent++;
+
+    for (const v of node.vars) {
+      const props = [];
+
+      switch (v.type) {
+        case 'str': props.push("type: 'string'"); break;
+        case 'int': props.push("type: 'integer'"); break;
+        case 'num': props.push("type: 'number'"); break;
+        case 'bool': props.push("type: 'boolean'"); break;
+        default: props.push(`type: '${v.type}'`); break;
+      }
+
+      for (const mod of v.modifiers) {
+        switch (mod.name) {
+          case 'required': props.push('required: true'); break;
+          case 'default': props.push(`default: ${this.expr(mod.args[0])}`); break;
+        }
+      }
+
+      this.emit(`${v.name}: { ${props.join(', ')} },`);
+    }
+
+    this.indent--;
+    this.emit('});');
+    this.emitRaw('');
+  }
+
+  visitEvery(node) {
+    this.runtimeImports.add('scheduleEvery');
+
+    const interval = this.expr(node.interval);
+    const needsAsync = this.bodyUsesAwait(node.body);
+    const asyncPrefix = needsAsync ? 'async ' : '';
+
+    this.emit(`scheduleEvery(${interval}, ${asyncPrefix}() => {`);
+    this.indent++;
+    for (const stmt of node.body) this.visitStatement(stmt);
+    this.indent--;
+    this.emit('});');
+    this.emitRaw('');
+  }
+
+  visitWatch(node) {
+    this.needsEventBus = true;
+
+    const params = node.params.length > 0 ? node.params.join(', ') : 'event';
+    const needsAsync = this.bodyUsesAwait(node.body);
+    const asyncPrefix = needsAsync ? 'async ' : '';
+
+    this.emit(`__eventBus.on('${node.eventName}', ${asyncPrefix}(${params}) => {`);
+    this.indent++;
+    for (const stmt of node.body) this.visitStatement(stmt);
+    this.indent--;
+    this.emit('});');
+    this.emitRaw('');
+  }
+
+  // ===== Expression generation =====
+
   expr(node) {
     if (!node) return 'undefined';
 
@@ -430,7 +860,7 @@ export class Generator {
         return `${this.expr(node.object)}?.${node.property}`;
 
       case 'Call':
-        return `${this.expr(node.callee)}(${node.args.map(a => this.expr(a)).join(', ')})`;
+        return this.generateCall(node);
 
       case 'IndexAccess':
         return `${this.expr(node.object)}[${this.expr(node.index)}]`;
@@ -483,6 +913,50 @@ export class Generator {
     }
   }
 
+  generateCall(node) {
+    const AUTO_IMPORT = { 'hash': 'hash', 'verify': 'verify', 'uuid': 'uuid' };
+
+    if (node.callee.type === 'Identifier' && AUTO_IMPORT[node.callee.name]) {
+      const runtimeFn = AUTO_IMPORT[node.callee.name];
+      this.runtimeImports.add(runtimeFn);
+      return `${runtimeFn}(${node.args.map(a => this.expr(a)).join(', ')})`;
+    }
+
+    if (node.callee.type === 'Identifier' && node.callee.name === 'sign') {
+      this.runtimeImports.add('jwtSign');
+      const args = node.args.map(a => this.expr(a));
+      if (args.length === 1 && this.authSecret) {
+        return `jwtSign(${args[0]}, __authSecret)`;
+      }
+      return `jwtSign(${args.join(', ')})`;
+    }
+
+    if (node.callee.type === 'MemberAccess' &&
+        node.callee.object.type === 'Identifier' &&
+        node.callee.object.name === 'api') {
+      this.runtimeImports.add('api');
+    }
+
+    if (node.callee.type === 'MemberAccess' &&
+        node.callee.object.type === 'Identifier' &&
+        node.callee.object.name === 'auth') {
+      if (node.callee.property === 'sign') {
+        this.runtimeImports.add('jwtSign');
+        const args = node.args.map(a => this.expr(a));
+        if (args.length === 1 && this.authSecret) {
+          return `jwtSign(${args[0]}, __authSecret)`;
+        }
+        return `jwtSign(${args.join(', ')})`;
+      }
+      if (node.callee.property === 'verify') {
+        this.runtimeImports.add('jwtVerify');
+        return `jwtVerify(${node.args.map(a => this.expr(a)).join(', ')})`;
+      }
+    }
+
+    return `${this.expr(node.callee)}(${node.args.map(a => this.expr(a)).join(', ')})`;
+  }
+
   generateString(strData) {
     if (!strData || !strData.parts) return '""';
 

package/src/index.js

@@ -3,7 +3,7 @@ import { Parser } from './parser.js';
 import { Generator } from './generator.js';
 import { preprocess } from './preprocess.js';
 
-export function compile(source, { mode = 'naide' } = {}) {
+export function compile(source, { mode = 'naide', runtimePath } = {}) {
   if (mode === 'x') {
     source = preprocess(source);
   }
@@ -11,7 +11,7 @@ export function compile(source, { mode = 'naide' } = {}) {
   const tokens = lexer.tokenize();
   const parser = new Parser(tokens);
   const ast = parser.parse();
-  const generator = new Generator();
+  const generator = new Generator({ runtimePath });
   const js = generator.generate(ast);
   return { js, ast, tokens, naide: mode === 'x' ? source : null };
 }