free-framework 4.4.0

package/compiler/parser.js

@@ -0,0 +1,410 @@
+/**
+ * compiler/parser.js
+ * Parser for the Free Framework (v4.3).
+ * Standardized braced-body parsing and raw code slicing.
+ */
+
+const { FreeSyntaxError } = require('./lexer');
+
+function expect(tokens, expectedValue, filename) {
+    const token = tokens.shift();
+    if (!token || token.value !== expectedValue) {
+        throw new FreeSyntaxError(`Expected "${expectedValue}" but found "${token ? token.value : 'EOF'}"`, filename, token ? token.line : 0, token ? token.col : 0);
+    }
+    return token;
+}
+
+function parse(tokens, filename = 'unknown.free', source = '') {
+    const ast = [];
+    while (tokens.length > 0) {
+        const token = tokens.shift();
+        if (token.type === 'KEYWORD') {
+            if (token.value === 'route') {
+                ast.push(parseRoute(tokens, filename, source));
+            } else if (token.value === 'model') {
+                ast.push(parseModel(tokens));
+            } else if (token.value === 'component') {
+                ast.push(parseComponent(tokens, filename, source));
+            } else if (token.value === 'auth') {
+                ast.push(parseAuth(tokens));
+            } else if (token.value === 'upload') {
+                ast.push(parseUpload(tokens));
+            } else if (token.value === 'error') {
+                ast.push(parseError(tokens));
+            } else if (token.value === 'action') {
+                ast.push(parseAction(tokens, source));
+            } else if (token.value === 'validate') {
+                ast.push(parseValidate(tokens, filename));
+            } else if (token.value === 'store') {
+                ast.push(parseStore(tokens, filename));
+            }
+        }
+    }
+    return ast;
+}
+
+function parseRoute(tokens, filename, source) {
+    const methodToken = tokens.shift();
+    const method = methodToken.value;
+    const path = tokens.shift().value.replace(/"/g, '');
+    let view = null;
+    let middleware = null;
+    let handler = null;
+
+    if (tokens[0] && tokens[0].value === '{') {
+        tokens.shift();
+        while (tokens.length > 0 && tokens[0].value !== '}') {
+            const next = tokens.shift();
+            if (next.value === 'view') view = tokens.shift().value.replace(/"/g, '');
+            else if (next.value === 'middleware') middleware = tokens.shift().value.replace(/"/g, '');
+            else if (next.value === 'handler') {
+                if (tokens[0] && tokens[0].value === '{') {
+                    handler = parseActionBody(tokens, source);
+                } else {
+                    handler = { type: 'action_ref', name: tokens.shift().value };
+                }
+            }
+        }
+        if (tokens[0] && tokens[0].value === '}') tokens.shift();
+    }
+    return { type: 'route', method, path, view, middleware, handler, line: methodToken.line };
+}
+
+function parseModel(tokens) {
+    const name = tokens.shift().value;
+    const fields = [];
+    if (tokens[0] && tokens[0].value === '{') tokens.shift();
+
+    while (tokens.length > 0 && tokens[0].value !== '}') {
+        if (tokens.length < 2) break; // Safety check
+
+        const fieldNameToken = tokens.shift();
+        const fieldName = fieldNameToken.value;
+
+        if (fieldName === 'timestamps') {
+            fields.push({ name: 'timestamps', type: 'directive' });
+            continue;
+        }
+
+        const fieldTypeToken = tokens.shift();
+        if (!fieldTypeToken) break;
+        const field = { name: fieldName, type: fieldTypeToken.value };
+
+        // Handle modifiers (unique, index, hidden, default) on the same line
+        while (tokens.length > 0 &&
+            tokens[0].value !== '}' &&
+            tokens[0].line === fieldTypeToken.line) {
+
+            const modToken = tokens.shift();
+            const mod = modToken.value;
+            // Skip brackets and commas
+            if (mod === '[' || mod === ']' || mod === ',') continue;
+
+            if (mod === 'unique') field.unique = true;
+            else if (mod === 'index') field.index = true;
+            else if (mod === 'primary') field.primary = true;
+            else if (mod === 'increment') field.increment = true;
+            else if (mod === 'hidden') field.hidden = true;
+            else if (mod === 'default') {
+                if (tokens[0] && tokens[0].value === ':') tokens.shift(); // skip :
+                if (tokens.length > 0) {
+                    const valToken = tokens.shift();
+                    let val = valToken.value.replace(/"/g, '');
+                    if (val === 'false') val = false;
+                    else if (val === 'true') val = true;
+                    else if (val === 'null') val = null;
+                    field.default = val;
+                }
+            }
+        }
+        fields.push(field);
+    }
+
+    if (tokens[0] && tokens[0].value === '}') tokens.shift();
+    return { type: 'model', name, fields };
+}
+
+function parseComponent(tokens, filename, source) {
+    const name = tokens.shift().value;
+    const states = [];
+    const body = [];
+    if (tokens[0] && tokens[0].value === '{') tokens.shift();
+    while (tokens.length > 0 && tokens[0].value !== '}' && tokens[0].value !== 'component') {
+        const next = tokens.shift();
+        if (next.value === 'state') {
+            const sName = tokens.shift().value;
+            if (tokens[0] && tokens[0].value === '=') tokens.shift();
+
+            let sVal = "";
+            let braceCount = 0;
+            let bracketCount = 0;
+
+            while (tokens.length > 0) {
+                const t = tokens.shift();
+                sVal += t.value;
+                if (t.value === '{') braceCount++;
+                if (t.value === '}') braceCount--;
+                if (t.value === '[') bracketCount++;
+                if (t.value === ']') bracketCount--;
+
+                if (braceCount === 0 && bracketCount === 0) {
+                    // Check if next token is on same line (simple case) or if we are done with complex
+                    if (tokens[0] && tokens[0].line !== t.line && !['{', '[', '(', ','].includes(t.value)) {
+                        break;
+                    }
+                }
+            }
+            sVal = sVal.replace(/"/g, '');
+            if (!isNaN(sVal) && sVal.trim() !== "" && !sVal.includes('.')) {
+                states.push({ name: sName, default: Number(sVal) });
+            } else {
+                states.push({ name: sName, default: sVal.trim() || "null" });
+            }
+        } else if (next.value === 'onMount') {
+            body.push({ type: 'onMount', code: parseActionBody(tokens, source) });
+        } else if (next.value === 'onDestroy') {
+            body.push({ type: 'onDestroy', code: parseActionBody(tokens, source) });
+        } else if (next.value === 'handler' || next.value === 'script') {
+            body.push({ type: next.value, code: parseActionBody(tokens, source) });
+        } else if (next.value === 'style') {
+            body.push({ type: 'style', content: parseActionBody(tokens, source) });
+        } else if (next.type === 'IDENTIFIER') {
+            body.push(parseTag(next, tokens, filename, source));
+        }
+    }
+    if (tokens[0] && tokens[0].value === '}') tokens.shift();
+    return { type: 'component', name, states, body };
+}
+
+function parseComponentBody(tokens, filename, source) {
+    const children = [];
+    if (tokens[0] && tokens[0].value === '{') {
+        tokens.shift();
+        while (tokens.length > 0 && tokens[0].value !== '}') {
+            const next = tokens.shift();
+            if (next.value === 'for' || next.value === 'loop') {
+                const isLoop = next.value === 'loop';
+                let item, list = "";
+
+                if (isLoop) {
+                    // loop list item {
+                    const loopTokens = [];
+                    while (tokens.length > 0 && tokens[0].value !== '{') {
+                        loopTokens.push(tokens.shift());
+                    }
+                    if (loopTokens.length < 2) throw new FreeSyntaxError("Loop requires list and item", filename, next.line, next.col);
+                    item = loopTokens.pop().value;
+                    list = loopTokens.map(t => (t.type === 'STRING' ? `"${t.value.replace(/"/g, '')}"` : t.value)).join('');
+                } else {
+                    // for item in list {
+                    item = tokens.shift().value;
+                    if (tokens[0] && tokens[0].value === 'in') tokens.shift();
+                    while (tokens.length > 0 && tokens[0].value !== '{') {
+                        list += (tokens[0].type === 'STRING' ? `"${tokens.shift().value.replace(/"/g, '')}"` : tokens.shift().value);
+                    }
+                }
+                const loopBody = parseComponentBody(tokens, filename, source);
+                children.push({ type: 'loop', item, list, body: loopBody });
+            } else if (next.value === 'if' || next.value === 'condition') {
+                let condition = "";
+                while (tokens.length > 0 && tokens[0].value !== '{') {
+                    condition += tokens.shift().value;
+                }
+                const ifBody = parseComponentBody(tokens, filename, source);
+                children.push({ type: 'condition', condition, body: ifBody });
+            } else if (next.value === 'script' || next.value === 'style' || next.value.startsWith('on-')) {
+                const type = next.value.startsWith('on-') ? 'event' : next.value;
+                const event = type === 'event' ? next.value.substring(3) : null;
+                const code = parseActionBody(tokens, source);
+                children.push({ type, event, code });
+            } else if (next.value === 'link') {
+                const txt = tokens.shift().value.replace(/"/g, '');
+                const lnk = tokens.shift().value.replace(/"/g, '');
+                const attrs = { href: lnk };
+                while (tokens.length > 0 && tokens[0].line === next.line && tokens[0].value !== '{' && tokens[0].value !== '}') {
+                    const attrName = tokens.shift().value;
+                    if (tokens[0] && tokens[0].value === '=') tokens.shift(); const attrVal = tokens.shift().value.replace(/"/g, '');
+                    attrs[attrName] = attrVal;
+                }
+                children.push({ type: 'tag', name: 'a', attributes: attrs, content: txt });
+            } else if (next.type === 'IDENTIFIER' || next.type === 'KEYWORD') {
+                children.push(parseTag(next, tokens, filename, source));
+            }
+        }
+        if (tokens[0] && tokens[0].value === '}') tokens.shift();
+    }
+    return children;
+}
+
+function parseTag(token, tokens, filename, source) {
+    const name = token.value;
+    const attributes = {};
+    const children = [];
+    let content = "";
+
+    while (tokens.length > 0) {
+        const next = tokens[0];
+        // Break on braces or other symbols (except - for identifiers)
+        if (next.value === '{' || next.value === '}' || (next.type === 'SYMBOL' && next.value !== '-' && next.value !== '=')) break;
+
+        const attrNameToken = tokens.shift();
+        const attrName = attrNameToken.value;
+
+        // Skip = if present
+        if (tokens[0] && tokens[0].value === '=') tokens.shift();
+
+        if (tokens[0] && tokens[0].value === '{') {
+            attributes[attrName] = parseActionBody(tokens, source);
+        } else if (tokens[0] && tokens[0].type !== 'SYMBOL' && tokens[0].type !== 'BRACE') {
+            attributes[attrName] = tokens.shift().value.replace(/"/g, '');
+        } else {
+            attributes[attrName] = "true";
+        }
+    }
+
+    if (tokens[0] && tokens[0].value === '{') {
+        tokens.shift();
+        while (tokens.length > 0 && tokens[0].value !== '}') {
+            const next = tokens.shift();
+            if (next.value === 'text') {
+                content += tokens.shift().value.replace(/"/g, '');
+            } else if (next.value === 'for' || next.value === 'loop') {
+                const isLoop = next.value === 'loop';
+                let item, list = "";
+                if (isLoop) {
+                    const loopTokens = [];
+                    while (tokens.length > 0 && tokens[0].value !== '{') {
+                        loopTokens.push(tokens.shift());
+                    }
+                    if (loopTokens.length < 2) throw new FreeSyntaxError("Loop requires list and item", filename, next.line, next.col);
+                    item = loopTokens.pop().value;
+                    list = loopTokens.map(t => (t.type === 'STRING' ? `"${t.value.replace(/"/g, '')}"` : t.value)).join('');
+                } else {
+                    item = tokens.shift().value;
+                    if (tokens[0] && tokens[0].value === 'in') tokens.shift();
+                    while (tokens.length > 0 && tokens[0].value !== '{') {
+                        list += (tokens[0].type === 'STRING' ? `"${tokens.shift().value.replace(/"/g, '')}"` : tokens.shift().value);
+                    }
+                }
+                const loopBody = parseComponentBody(tokens, filename, source);
+                children.push({ type: 'loop', item, list, body: loopBody });
+            } else if (next.value === 'if' || next.value === 'condition') {
+                let condition = "";
+                while (tokens.length > 0 && tokens[0].value !== '{') {
+                    condition += tokens.shift().value;
+                }
+                const ifBody = parseComponentBody(tokens, filename, source);
+                children.push({ type: 'condition', condition, body: ifBody });
+            } else if (next.value === 'script' || next.value === 'style' || next.value.startsWith('on-')) {
+                const type = next.value.startsWith('on-') ? 'event' : next.value;
+                const event = type === 'event' ? next.value.substring(3) : null;
+                const code = parseActionBody(tokens, source);
+                children.push({ type, event, code });
+            } else if (next.value === 'link') {
+                const txt = tokens.shift().value.replace(/"/g, '');
+                const lnk = tokens.shift().value.replace(/"/g, '');
+                const attrs = { href: lnk };
+                while (tokens.length > 0 && tokens[0].line === next.line && tokens[0].value !== '{' && tokens[0].value !== '}') {
+                    const attrName = tokens.shift().value;
+                    if (tokens[0] && tokens[0].value === '=') tokens.shift(); const attrVal = tokens.shift().value.replace(/"/g, '');
+                    attrs[attrName] = attrVal;
+                }
+                children.push({ type: 'tag', name: 'a', attributes: attrs, content: txt });
+            } else if (next.type === 'IDENTIFIER') {
+                children.push(parseTag(next, tokens, filename, source));
+            }
+        }
+        if (tokens[0] && tokens[0].value === '}') tokens.shift();
+    }
+    return { type: 'tag', name, attributes, children, content };
+}
+
+function parseActionBody(tokens, source = '') {
+    if (tokens[0] && tokens[0].value === '{') {
+        const startToken = tokens.shift();
+        let braceCount = 1;
+        while (tokens.length > 0 && braceCount > 0) {
+            const next = tokens.shift();
+            if (next.value === '{') braceCount++;
+            if (next.value === '}') braceCount--;
+            if (braceCount === 0) {
+                return source.slice(startToken.end, next.start).trim();
+            }
+        }
+    }
+    return '';
+}
+
+function parseAction(tokens, source) {
+    const nameToken = tokens.shift();
+    let name = nameToken.value;
+    let params = [];
+
+    // Support for parameterized actions: action myAction(id, name) { ... }
+    if (tokens[0] && tokens[0].value === '(') {
+        tokens.shift(); // consume '('
+        while (tokens.length > 0 && tokens[0].value !== ')') {
+            const pt = tokens.shift();
+            if (pt.value !== ',') {
+                params.push(pt.value);
+            }
+        }
+        if (tokens[0] && tokens[0].value === ')') tokens.shift(); // consume ')'
+    } else if (name.includes('(')) {
+        // Handle case where lexer smushed it together: myAction(id)
+        const parts = name.split('(');
+        name = parts[0];
+        const argPart = parts[1].replace(')', '');
+        if (argPart) {
+            params = argPart.split(',').map(p => p.trim()).filter(Boolean);
+        }
+    }
+
+    const code = parseActionBody(tokens, source);
+    return { type: 'action', name, params, code };
+}
+
+function parseAuth(tokens) {
+    const config = {};
+    if (tokens[0] && tokens[0].value === '{') tokens.shift();
+    while (tokens.length > 0 && tokens[0].value !== '}') {
+        const key = tokens.shift().value;
+        const val = tokens.shift().value.replace(/"/g, '');
+        config[key] = val;
+    }
+    if (tokens[0] && tokens[0].value === '}') tokens.shift();
+    return { type: 'auth', config };
+}
+
+function parseUpload(tokens) {
+    const name = tokens.shift().value;
+    const config = {};
+    if (tokens[0] && tokens[0].value === '{') tokens.shift();
+    while (tokens.length > 0 && tokens[0].value !== '}') {
+        const key = tokens.shift().value;
+        const val = tokens.shift().value.replace(/"/g, '');
+        config[key] = val;
+    }
+    if (tokens[0] && tokens[0].value === '}') tokens.shift();
+    return { type: 'upload', name, config };
+}
+
+function parseError(tokens) {
+    const code = tokens.shift().value;
+    const view = tokens.shift().value.replace(/"/g, '');
+    return { type: 'error', code, view };
+}
+
+function parseValidate(tokens, filename) {
+    const model = tokens.shift().value;
+    const rules = parseActionBody(tokens);
+    return { type: 'validate', model, rules };
+}
+
+function parseStore(tokens, filename) {
+    const name = tokens.shift().value;
+    const body = parseActionBody(tokens);
+    return { type: 'store', name, body };
+}
+
+module.exports = { parse, FreeSyntaxError };

package/database/model.js

@@ -0,0 +1,6 @@
+/**
+ * database/model.js
+ * Proxy to centralized Model in orm.js
+ */
+const { Model } = require('./orm');
+module.exports = { Model };