veko-framework 1.0.0

package/src/compiler/lexer.js

@@ -0,0 +1,114 @@
+/**
+ * Veko v1 – Lexer (structure only; do-body is extracted from source)
+ */
+
+export const TT = {
+  KEYWORD: 'KEYWORD',
+  IDENT: 'IDENT',
+  NUMBER: 'NUMBER',
+  LPAREN: 'LPAREN',
+  RPAREN: 'RPAREN',
+  LBRACE: 'LBRACE',
+  RBRACE: 'RBRACE',
+  LBRACKET: 'LBRACKET',
+  RBRACKET: 'RBRACKET',
+  STRING: 'STRING',
+  FAT_ARROW: 'FAT_ARROW',
+  COMMA: 'COMMA',
+  COLON: 'COLON',
+  PIPE: 'PIPE',
+  QUESTION: 'QUESTION',
+  HTTP_METHOD: 'HTTP_METHOD',
+  EOF: 'EOF',
+};
+
+const KEYWORDS = new Set(['data', 'do', 'route', 'migration', 'import']);
+const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'DELETE', 'PATCH']);
+
+export function lex(source) {
+  const tokens = [];
+  let i = 0;
+  let line = 1;
+  let column = 1;
+
+  function peek(offset = 0) {
+    return source[i + offset];
+  }
+  function advance() {
+    const c = source[i++];
+    if (c === '\n') {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+    return c;
+  }
+  function add(type, value) {
+    tokens.push({ type, value, line, column });
+  }
+
+  while (i < source.length) {
+    if (/\s/.test(peek())) {
+      advance();
+      continue;
+    }
+    if (peek() === '/' && peek(1) === '/') {
+      while (i < source.length && peek() !== '\n') advance();
+      continue;
+    }
+    if (peek() === '/' && peek(1) === '*') {
+      advance();
+      advance();
+      while (i < source.length && !(peek() === '*' && peek(1) === '/')) advance();
+      advance();
+      advance();
+      continue;
+    }
+    if (peek() === '=' && peek(1) === '>') {
+      advance();
+      advance();
+      add(TT.FAT_ARROW, '=>');
+      continue;
+    }
+    const singles = {
+      '{': TT.LBRACE, '}': TT.RBRACE, '(': TT.LPAREN, ')': TT.RPAREN,
+      '[': TT.LBRACKET, ']': TT.RBRACKET, ',': TT.COMMA, ':': TT.COLON,
+      '|': TT.PIPE, '?': TT.QUESTION,
+    };
+    if (singles[peek()]) {
+      add(singles[peek()], advance());
+      continue;
+    }
+    if (peek() === '"' || peek() === "'") {
+      const q = advance();
+      const start = i;
+      while (i < source.length && peek() !== q) {
+        if (peek() === '\\') advance();
+        advance();
+      }
+      if (i < source.length) advance();
+      add(TT.STRING, source.slice(start, i - 1));
+      continue;
+    }
+    if (/[0-9]/.test(peek())) {
+      const start = i;
+      while (i < source.length && /[0-9]/.test(peek())) advance();
+      add(TT.NUMBER, source.slice(start, i));
+      continue;
+    }
+    if (/[a-zA-Z_]/.test(peek())) {
+      const start = i;
+      while (i < source.length && /[a-zA-Z0-9_]/.test(peek())) advance();
+      const value = source.slice(start, i);
+      if (KEYWORDS.has(value)) add(TT.KEYWORD, value);
+      else if (HTTP_METHODS.has(value)) add(TT.HTTP_METHOD, value);
+      else add(TT.IDENT, value);
+      continue;
+    }
+    advance();
+  }
+
+  add(TT.EOF, '');
+  return tokens;
+}

package/src/compiler/parser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Type declarations for parser.js
+ */
+
+import type { AST } from './types';
+
+export function parse(source: string): AST;

package/src/compiler/parser.js

@@ -0,0 +1,185 @@
+/**
+ * Veko v1 – Parser (AST for data, do, route, migration)
+ */
+
+import { lex, TT } from './lexer.js';
+import { locateBraceInSource, extractRawBlock } from './source-utils.js';
+
+/**
+ * @param {string} source
+ * @returns {import('./types.js').AST}
+ */
+export function parse(source) {
+  const tokens = lex(source);
+  let pos = 0;
+
+  function peek(o = 0) {
+    return tokens[pos + o];
+  }
+  function consume(type, value) {
+    const t = tokens[pos];
+    if (!t) throw new Error('Unexpected end of file');
+    if (type && t.type !== type) throw new Error(`Line ${t.line}: expected ${type}, got ${t.type}`);
+    if (value !== undefined && t.value !== value) throw new Error(`Line ${t.line}: expected "${value}"`);
+    pos++;
+    return t;
+  }
+  function check(type, value) {
+    const t = tokens[pos];
+    return t && t.type === type && (value === undefined || t.value === value);
+  }
+
+  const ast = { dataBlocks: [], doBlocks: [], routeLines: [], migrations: [], imports: [] };
+
+  while (!check(TT.EOF)) {
+    if (check(TT.KEYWORD, 'import')) {
+      consume(TT.KEYWORD);
+      const path = consume(TT.STRING).value;
+      ast.imports.push({ path });
+      continue;
+    }
+
+    if (check(TT.KEYWORD, 'data')) {
+      consume(TT.KEYWORD);
+      const name = consume(TT.IDENT).value;
+      consume(TT.LBRACE);
+      const fields = [];
+      while (!check(TT.RBRACE) && !check(TT.EOF)) {
+        if (check(TT.COMMA)) {
+          consume(TT.COMMA);
+          continue;
+        }
+        const fieldName = consume(TT.IDENT).value;
+        consume(TT.COLON);
+        const typeTok = consume(TT.IDENT);
+        let typeName = typeTok.value;
+        let typeArgs = {};
+        if (check(TT.LPAREN)) {
+          consume(TT.LPAREN);
+          while (!check(TT.RPAREN) && !check(TT.EOF)) {
+            if (check(TT.PIPE) || check(TT.COMMA)) {
+              consume(tokens[pos].type);
+              continue;
+            }
+            const k = consume(TT.IDENT).value;
+            if (check(TT.COLON)) {
+              consume(TT.COLON);
+              const vTok = check(TT.NUMBER) ? consume(TT.NUMBER) : consume(TT.IDENT);
+              const v = vTok.value;
+              typeArgs[k] = isNaN(Number(v)) ? v : Number(v);
+            } else {
+              if (!typeArgs.enum) typeArgs.enum = [];
+              typeArgs.enum.push(k);
+            }
+          }
+          consume(TT.RPAREN);
+        }
+        const optional = check(TT.QUESTION) ? (consume(TT.QUESTION), true) : false;
+        fields.push({ name: fieldName, type: typeName, optional, args: typeArgs });
+      }
+      consume(TT.RBRACE);
+      ast.dataBlocks.push({ name, fields });
+      continue;
+    }
+
+    if (check(TT.KEYWORD, 'do')) {
+      const kw = consume(TT.KEYWORD);
+      const name = consume(TT.IDENT).value;
+      consume(TT.LPAREN);
+      while (!check(TT.RPAREN) && !check(TT.EOF)) {
+        if (check(TT.COMMA)) consume(TT.COMMA);
+        else pos++;
+      }
+      consume(TT.RPAREN);
+      const lbrace = tokens[pos];
+      const openIdx = locateBraceInSource(source, lbrace.line);
+      consume(TT.LBRACE);
+      const raw = extractRawBlock(source, openIdx);
+      let depth = 1;
+      while (pos < tokens.length && depth > 0) {
+        if (check(TT.LBRACE)) depth++;
+        else if (check(TT.RBRACE)) {
+          depth--;
+          if (depth === 0) {
+            consume(TT.RBRACE);
+            break;
+          }
+        }
+        pos++;
+      }
+      ast.doBlocks.push({ name, body: raw.body, line: kw.line });
+      continue;
+    }
+
+    if (check(TT.KEYWORD, 'route')) {
+      consume(TT.KEYWORD);
+      consume(TT.LBRACE);
+      while (!check(TT.RBRACE) && !check(TT.EOF)) {
+        if (!check(TT.HTTP_METHOD)) {
+          pos++;
+          continue;
+        }
+        const method = consume(TT.HTTP_METHOD).value;
+        const path = consume(TT.STRING).value;
+        consume(TT.FAT_ARROW);
+        const pipeline = [];
+        if (check(TT.LBRACKET)) consume(TT.LBRACKET);
+        const inBracket = tokens[pos - 1]?.value === '[';
+        while (
+          !check(TT.EOF) &&
+          !check(TT.HTTP_METHOD) &&
+          !check(TT.RBRACE) &&
+          !(inBracket && check(TT.RBRACKET))
+        ) {
+          if (check(TT.COMMA)) {
+            consume(TT.COMMA);
+            continue;
+          }
+          const ident = consume(TT.IDENT).value;
+          if (ident === 'validate' && check(TT.LPAREN)) {
+            consume(TT.LPAREN);
+            const schema = consume(TT.IDENT).value;
+            consume(TT.RPAREN);
+            pipeline.push({ kind: 'validate', schema });
+          } else if (ident === 'auth') {
+            pipeline.push({ kind: 'auth' });
+          } else {
+            pipeline.push({ kind: 'action', name: ident });
+          }
+        }
+        if (inBracket && check(TT.RBRACKET)) consume(TT.RBRACKET);
+        ast.routeLines.push({ method, path, pipeline });
+      }
+      consume(TT.RBRACE);
+      continue;
+    }
+
+    if (check(TT.KEYWORD, 'migration')) {
+      consume(TT.KEYWORD);
+      const version = consume(TT.STRING).value;
+      consume(TT.LBRACE);
+      const operations = [];
+      while (!check(TT.RBRACE) && !check(TT.EOF)) {
+        const op = consume(TT.IDENT).value;
+        const table = consume(TT.STRING).value;
+        if (op === 'addColumn') {
+          const column = consume(TT.IDENT).value;
+          const type = consume(TT.IDENT).value;
+          operations.push({ op, table, column, type });
+        } else if (op === 'dropColumn') {
+          const column = consume(TT.IDENT).value;
+          operations.push({ op, table, column });
+        } else {
+          operations.push({ op, table });
+        }
+      }
+      consume(TT.RBRACE);
+      ast.migrations.push({ version, operations });
+      continue;
+    }
+
+    pos++;
+  }
+
+  return ast;
+}

package/src/compiler/resolver.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Type declarations for resolver.js
+ */
+
+import type { AST } from './types';
+
+export function resolveModules(
+  entryFile: string,
+  rootDir?: string
+): AST;

package/src/compiler/resolver.js

@@ -0,0 +1,88 @@
+/**
+ * Veko v1 – Module Resolver
+ * Handles import statements, resolves .vk files, and merges ASTs
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { parse } from './parser.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Resolves and loads all imported modules, merging their ASTs
+ * @param {string} entryFile - Path to the main .vk file
+ * @param {string} [rootDir] - Project root directory
+ * @returns {import('./types.js').AST} Merged AST from all files
+ */
+export function resolveModules(entryFile, rootDir) {
+  const root = rootDir ? path.resolve(rootDir) : path.dirname(entryFile);
+  const visited = new Set();
+  const resolved = new Map();
+  const loading = new Set();
+
+  function resolvePath(importPath, fromFile) {
+    let normalized = importPath.replace(/\.vk$/, '');
+    if (!normalized.endsWith('.vk')) {
+      normalized += '.vk';
+    }
+    if (normalized.startsWith('./') || normalized.startsWith('../')) {
+      return path.resolve(path.dirname(fromFile), normalized);
+    }
+    if (path.isAbsolute(normalized)) {
+      return normalized;
+    }
+    return path.resolve(root, normalized);
+  }
+
+  function loadModule(filePath) {
+    const normalizedPath = path.normalize(filePath);
+
+    if (loading.has(normalizedPath)) {
+      throw new Error(`Circular dependency detected: ${normalizedPath} is already being loaded`);
+    }
+    if (resolved.has(normalizedPath)) {
+      return resolved.get(normalizedPath);
+    }
+    if (!fs.existsSync(normalizedPath)) {
+      throw new Error(`Import not found: ${normalizedPath} (resolved from ${filePath})`);
+    }
+
+    loading.add(normalizedPath);
+    visited.add(normalizedPath);
+
+    try {
+      const source = fs.readFileSync(normalizedPath, 'utf-8');
+      const ast = parse(source);
+
+      for (const imp of ast.imports) {
+        const importedPath = resolvePath(imp.path, normalizedPath);
+        const importedAST = loadModule(importedPath);
+        ast.dataBlocks.push(...importedAST.dataBlocks);
+        ast.doBlocks.push(...importedAST.doBlocks);
+        ast.routeLines.push(...importedAST.routeLines);
+        ast.migrations.push(...importedAST.migrations);
+      }
+
+      resolved.set(normalizedPath, ast);
+      return ast;
+    } finally {
+      loading.delete(normalizedPath);
+    }
+  }
+
+  const entryPath = path.isAbsolute(entryFile)
+    ? entryFile
+    : path.resolve(root, entryFile);
+
+  const mainAST = loadModule(entryPath);
+
+  return {
+    dataBlocks: mainAST.dataBlocks,
+    doBlocks: mainAST.doBlocks,
+    routeLines: mainAST.routeLines,
+    migrations: mainAST.migrations,
+    imports: [],
+  };
+}

package/src/compiler/source-utils.js

@@ -0,0 +1,46 @@
+/**
+ * Locate opening brace at token's line in source; extract content to matching closing brace.
+ */
+
+export function locateBraceInSource(source, line) {
+  let currentLine = 1;
+  let i = 0;
+  while (i < source.length) {
+    if (currentLine === line) {
+      while (i < source.length && source[i] !== '{') i++;
+      return i;
+    }
+    if (source[i] === '\n') currentLine++;
+    i++;
+  }
+  throw new Error(`Line ${line} not found in source`);
+}
+
+export function extractRawBlock(source, openBraceIndex) {
+  let depth = 1;
+  let i = openBraceIndex + 1;
+  while (i < source.length && depth > 0) {
+    const c = source[i];
+    if (c === '"' || c === "'" || c === '`') {
+      const q = c;
+      i++;
+      while (i < source.length) {
+        if (source[i] === '\\') {
+          i += 2;
+          continue;
+        }
+        if (source[i] === q) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (c === '{') depth++;
+    else if (c === '}') depth--;
+    i++;
+  }
+  if (depth !== 0) throw new Error('Unbalanced braces');
+  return { body: source.slice(openBraceIndex + 1, i - 1).trim(), endIndex: i };
+}

package/src/compiler/types.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Type definitions for Veko AST
+ */
+
+export interface FieldDef {
+  name: string;
+  type: string;
+  optional: boolean;
+  args: Record<string, any>;
+}
+
+export interface DataBlock {
+  name: string;
+  fields: FieldDef[];
+}
+
+export interface DoBlock {
+  name: string;
+  body: string;
+  line: number;
+}
+
+export type PipelineStep =
+  | { kind: 'validate'; schema: string }
+  | { kind: 'auth' }
+  | { kind: 'action'; name: string };
+
+export interface RouteLine {
+  method: string;
+  path: string;
+  pipeline: PipelineStep[];
+}
+
+export interface Migration {
+  version: string;
+  operations: Array<{
+    op: string;
+    table: string;
+    column?: string;
+    type?: string;
+  }>;
+}
+
+export interface AST {
+  dataBlocks: DataBlock[];
+  doBlocks: DoBlock[];
+  routeLines: RouteLine[];
+  migrations: Migration[];
+  imports?: Array<{ path: string }>;
+}

package/src/compiler/types.js

@@ -0,0 +1,15 @@
+/**
+ * Veko v1 – Type definitions for AST (JSDoc for IDE/type gen)
+ */
+
+/**
+ * @typedef {{ name: string, type: string, optional: boolean, args: Record<string,any> }} FieldDef
+ * @typedef {{ name: string, fields: FieldDef[] }} DataBlock
+ * @typedef {{ name: string, body: string, line: number }} DoBlock
+ * @typedef {{ kind: 'validate', schema: string }|{ kind: 'auth' }|{ kind: 'action', name: string }} PipelineStep
+ * @typedef {{ method: string, path: string, pipeline: PipelineStep[] }} RouteLine
+ * @typedef {{ version: string, operations: { op: string, table: string, column?: string, type?: string }[] }} Migration
+ * @typedef {{ dataBlocks: DataBlock[], doBlocks: DoBlock[], routeLines: RouteLine[], migrations: Migration[] }} AST
+ */
+
+export default {};

package/src/config/config-types.js

@@ -0,0 +1,35 @@
+/**
+ * Veko v1 – Config and resolved config types
+ */
+
+/**
+ * @typedef {Object} VekoPlugin
+ * @property {function(object): void} [onRouteRegister]
+ * @property {function(object): Promise<object>|object} [beforeAction]
+ * @property {function(any): Promise<any>|any} [afterAction]
+ */
+
+/**
+ * @typedef {Object} VekoConfig
+ * @property {string} [entry='./api.vk']
+ * @property {{ server?: string, types?: string }} [output]
+ * @property {'sqlite'|'postgres'} [adapter='sqlite']
+ * @property {{ sqlite?: { path?: string }, postgres?: { connectionString?: string, ssl?: object } }} [database]
+ * @property {{ port?: number }} [server]
+ * @property {{ table?: string, dir?: string }} [migrations]
+ * @property {VekoPlugin[]} [plugins]
+ */
+
+/**
+ * @typedef {Object} ResolvedConfig
+ * @property {string} root
+ * @property {string} entry
+ * @property {{ server: string, types: string }} output
+ * @property {'sqlite'|'postgres'} adapter
+ * @property {object} database
+ * @property {{ port?: number }} server
+ * @property {{ table: string, dir: string }} migrations
+ * @property {VekoPlugin[]} plugins
+ */
+
+export default {};

package/src/config/defaults.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Type declarations for defaults.js
+ */
+
+export const DEFAULTS: {
+  readonly PORT: number;
+  readonly HOST: string;
+  readonly DB_FILE: string;
+  readonly DB_FILE_TEST: string;
+  readonly JWT_SECRET: string;
+  readonly LOG_LEVEL: string;
+};
+
+export function env(key: string): string | undefined;
+
+export default typeof DEFAULTS;

package/src/config/defaults.js

@@ -0,0 +1,36 @@
+/**
+ * Veko v1 – Default configuration values
+ * Single source of truth for compiler, CLI, and runtime.
+ */
+
+export const DEFAULTS = Object.freeze({
+  PORT: 3000,
+  HOST: '0.0.0.0',
+  DB_FILE: 'veko.db',
+  DB_FILE_TEST: 'veko.test.db',
+  /** Dev-only default; production must set JWT_SECRET in the environment. */
+  JWT_SECRET: 'changeme-secret',
+  LOG_LEVEL: 'info',
+});
+
+/**
+ * @param {string} [key] - Env key (e.g. 'PORT'). Returns process.env[key] or default.
+ */
+export function env(key) {
+  switch (key) {
+    case 'PORT':
+      return process.env.PORT != null ? process.env.PORT : String(DEFAULTS.PORT);
+    case 'HOST':
+      return process.env.HOST || DEFAULTS.HOST;
+    case 'DB_FILE':
+      return process.env.DB_FILE || (process.env.NODE_ENV === 'test' ? DEFAULTS.DB_FILE_TEST : DEFAULTS.DB_FILE);
+    case 'JWT_SECRET':
+      return process.env.JWT_SECRET || DEFAULTS.JWT_SECRET;
+    case 'LOG_LEVEL':
+      return process.env.LOG_LEVEL || DEFAULTS.LOG_LEVEL;
+    default:
+      return process.env?.[key];
+  }
+}
+
+export default DEFAULTS;

package/src/config/index.js

@@ -0,0 +1,6 @@
+/**
+ * Veko v1 – Config module (defaults, loadConfig, types)
+ */
+
+export { DEFAULTS, env } from './defaults.js';
+export { loadConfig } from './load-config.js';

package/src/config/load-config.js

@@ -0,0 +1,59 @@
+/**
+ * Veko v1 – Load veko.config.js and return resolved config
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { DEFAULTS } from './defaults.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Load veko.config.js from root. Returns resolved paths and options.
+ * When rootDir is omitted, uses process.cwd() so that `npx veko build` from a consumer app uses that app's directory.
+ * @param {string} [rootDir] - Project root (default: process.cwd())
+ * @returns {Promise<import('./config-types.js').ResolvedConfig>}
+ */
+export async function loadConfig(rootDir) {
+  const root = rootDir ? path.resolve(rootDir) : process.cwd();
+  const configPath = path.join(root, 'veko.config.js');
+
+  if (!fs.existsSync(configPath)) {
+    return {
+      root,
+      entry: path.join(root, 'api.vk'),
+      output: {
+        server: path.join(root, 'generated', 'server.js'),
+        types: path.join(root, 'generated', 'types.d.ts'),
+      },
+      adapter: 'sqlite',
+      database: {},
+      server: { port: DEFAULTS.PORT },
+      migrations: {
+        table: '_veko_migrations',
+        dir: path.join(root, 'migrations'),
+      },
+      plugins: [],
+    };
+  }
+
+  const mod = await import(pathToFileURL(configPath).href);
+  const c = mod.default || mod;
+
+  return {
+    root,
+    entry: path.resolve(root, c.entry || 'api.vk'),
+    output: {
+      server: path.resolve(root, c.output?.server || 'generated/server.js'),
+      types: path.resolve(root, c.output?.types || 'generated/types.d.ts'),
+    },
+    adapter: c.adapter || 'sqlite',
+    database: c.database || {},
+    server: c.server || {},
+    migrations: c.migrations || {},
+    plugins: c.plugins || [],
+  };
+}
+
+export default loadConfig;