agentlang 0.0.2

package/out/runtime/module.js

@@ -0,0 +1,1786 @@
+import chalk from 'chalk';
+import { isRelNodes, isLiteral, } from '../language/generated/ast.js';
+import { Path, splitFqName, isString, isNumber, isBoolean, isFqName, makeFqName, DefaultModuleName, joinStatements, isMinusZero, now, findMetaSchema, findAllPrePostTriggerSchema, asCrudType, isPath, findUqCompositeAttributes, escapeFqName, } from './util.js';
+import { parseStatement } from '../language/parser.js';
+import { AdminSession } from './auth/defs.js';
+import { DefaultIdAttributeName, PathAttributeName } from './defs.js';
+export class ModuleEntry {
+    constructor(name, moduleName) {
+        this.name = name;
+        this.moduleName = moduleName;
+    }
+    getFqName() {
+        return makeFqName(this.moduleName, this.name);
+    }
+}
+function normalizePropertyNames(props) {
+    // Convert iterator to array for compatibility with different Node.js versions
+    const normKs = Array.from(props.keys()).filter((k) => {
+        return k.charAt(0) === '@';
+    });
+    normKs.forEach((k) => {
+        const v = props.get(k);
+        props.delete(k);
+        props.set(k.substring(1), v);
+    });
+}
+const SystemAttributeProperty = 'system-attribute';
+const SystemDefinedEvent = 'system-event';
+function setAsSystemAttribute(attrSpec) {
+    const props = attrSpec.properties ? attrSpec.properties : new Map();
+    props.set(SystemAttributeProperty, true);
+    attrSpec.properties = props;
+}
+function isSystemAttribute(attrSpec) {
+    if (attrSpec.properties) {
+        return attrSpec.properties.get(SystemAttributeProperty) == true;
+    }
+    return false;
+}
+function recordSchemaToString(scm) {
+    const ss = [];
+    scm.forEach((attrSpec, n) => {
+        if (!isSystemAttribute(attrSpec)) {
+            ss.push(`    ${n} ${attributeSpecToString(attrSpec)}`);
+        }
+    });
+    return `{ \n${ss.join(',\n')} \n}`;
+}
+function attributeSpecToString(attrSpec) {
+    let s = `${attrSpec.type}`;
+    if (attrSpec.properties) {
+        const ps = [];
+        attrSpec.properties.forEach((v, k) => {
+            if (v == true)
+                ps.push(`@${k}`);
+            else
+                ps.push(`@${k}${v}`);
+        });
+        s = s.concat(ps.join(' '));
+    }
+    return s;
+}
+export function newRecordSchema() {
+    return new Map();
+}
+export function newMeta() {
+    return new Map();
+}
+export var RecordType;
+(function (RecordType) {
+    RecordType[RecordType["RECORD"] = 0] = "RECORD";
+    RecordType[RecordType["ENTITY"] = 1] = "ENTITY";
+    RecordType[RecordType["EVENT"] = 2] = "EVENT";
+    RecordType[RecordType["RELATIONSHIP"] = 3] = "RELATIONSHIP";
+})(RecordType || (RecordType = {}));
+function normalizeMetaValue(metaValue) {
+    if (!isLiteral(metaValue)) {
+        throw new Error(`Invalid entry ${metaValue} in meta specification - expected a literal`);
+    }
+    const v = metaValue;
+    if (v.array) {
+        return v.array.vals.map((value) => {
+            return normalizeMetaValue(value.pattern.literal);
+        });
+    }
+    else if (v.bool != undefined) {
+        return v.bool;
+    }
+    else if (v.id) {
+        return v.id;
+    }
+    else if (v.map) {
+        const result = new Map();
+        v.map.entries.forEach((value) => {
+            result.set(value.key, normalizeMetaValue(value.value));
+        });
+        return result;
+    }
+    else if (v.ref) {
+        return v.ref;
+    }
+    else if (v.num) {
+        return v.num;
+    }
+    else if (v.str) {
+        return v.str;
+    }
+    else {
+        throw new Error(`Invalid value ${metaValue} passed to meta specification`);
+    }
+}
+function asTriggerInfo(te) {
+    return {
+        eventName: te.event,
+        async: te.async ? true : false,
+    };
+}
+export class Record extends ModuleEntry {
+    constructor(name, moduleName, scm, parentEntryName) {
+        super(name, moduleName);
+        this.type = RecordType.RECORD;
+        this.parentEntryName = parentEntryName;
+        this.schema = parentEntryName
+            ? cloneParentSchema(parentEntryName, moduleName)
+            : newRecordSchema();
+        const attributes = scm ? scm.attributes : undefined;
+        if (attributes != undefined) {
+            attributes.forEach((a) => {
+                var _a, _b;
+                verifyAttribute(a);
+                let props = asPropertiesMap(a.properties);
+                const isArrayType = a.arrayType ? true : false;
+                let t = isArrayType ? a.arrayType : a.type;
+                if (a.refSpec) {
+                    let fp = a.refSpec.ref;
+                    const rp = splitFqName(fp);
+                    if (!rp.hasModule()) {
+                        rp.setModuleName(this.moduleName);
+                        fp = rp.asFqName();
+                    }
+                    if (props == undefined) {
+                        props = new Map();
+                    }
+                    props.set('ref', escapeFqName(fp));
+                    t = 'Path';
+                }
+                const enumValues = (_a = a.enumSpec) === null || _a === void 0 ? void 0 : _a.values;
+                const oneOfRef = (_b = a.oneOfSpec) === null || _b === void 0 ? void 0 : _b.ref;
+                if (!t) {
+                    if (enumValues || oneOfRef) {
+                        t = 'String';
+                    }
+                    else {
+                        throw new Error(`Attribute ${a.name} requires a type`);
+                    }
+                }
+                if (a.expr) {
+                    if (props == undefined) {
+                        props = new Map();
+                    }
+                    props.set('expr', a.expr).set('optional', true);
+                }
+                const isObjectType = t == 'Map' || !isBuiltInType(t);
+                if (isArrayType || isObjectType || enumValues || oneOfRef) {
+                    if (props == undefined) {
+                        props = new Map();
+                    }
+                    if (isArrayType)
+                        props.set('array', true);
+                    if (isObjectType)
+                        props.set('object', true);
+                    if (enumValues)
+                        props.set('one-of', new Set(enumValues));
+                    if (oneOfRef) {
+                        props.set('one-of-ref', oneOfRef);
+                        this.addOneOfRefAttribute(a.name);
+                    }
+                }
+                this.schema.set(a.name, { type: t, properties: props });
+            });
+        }
+        const meta = findMetaSchema(scm);
+        if (meta) {
+            meta.spec.entries.forEach((entry) => {
+                if (entry.key.str)
+                    this.addMeta(entry.key.str, normalizeMetaValue(entry.value));
+                else
+                    throw new Error(`Key must be a string for meta-definition in ${this.moduleName}/${this.name}`);
+            });
+        }
+        const prepostTrigs = findAllPrePostTriggerSchema(scm);
+        if (prepostTrigs) {
+            prepostTrigs.forEach((ppt) => {
+                if (ppt.after) {
+                    if (this.afterTriggers == undefined) {
+                        this.afterTriggers = new Map();
+                    }
+                    ppt.after.triggers.entries.forEach((te) => {
+                        if (this.afterTriggers)
+                            this.afterTriggers.set(asCrudType(te.on), asTriggerInfo(te));
+                    });
+                }
+                else if (ppt.before) {
+                    if (this.beforeTriggers == undefined) {
+                        this.beforeTriggers = new Map();
+                    }
+                    ppt.before.triggers.entries.forEach((te) => {
+                        if (this.beforeTriggers)
+                            this.beforeTriggers.set(asCrudType(te.on), asTriggerInfo(te));
+                    });
+                }
+            });
+        }
+        this.compositeUqAttributes = findUqCompositeAttributes(scm);
+    }
+    addOneOfRefAttribute(s) {
+        if (this.oneOfRefAttributes == undefined) {
+            this.oneOfRefAttributes = [];
+        }
+        this.oneOfRefAttributes.push(s);
+        return this;
+    }
+    getCompositeUniqueAttributes() {
+        return this.compositeUqAttributes;
+    }
+    getPreTriggerInfo(crudType) {
+        if (this.beforeTriggers) {
+            return this.beforeTriggers.get(crudType);
+        }
+        return undefined;
+    }
+    getPostTriggerInfo(crudType) {
+        if (this.afterTriggers) {
+            return this.afterTriggers.get(crudType);
+        }
+        return undefined;
+    }
+    addMeta(k, v) {
+        if (!this.meta) {
+            this.meta = newMeta();
+        }
+        this.meta.set(k, v);
+    }
+    getMeta(k) {
+        if (this.meta) {
+            return this.meta.get(k);
+        }
+        else {
+            return undefined;
+        }
+    }
+    getFullTextSearchAttributes() {
+        const fts = this.getMeta('fullTextSearch');
+        if (fts) {
+            if (fts instanceof Array) {
+                return fts;
+            }
+            else if (fts == '*') {
+                return [...this.schema.keys()];
+            }
+            else {
+                return undefined;
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+    addAttribute(n, attrSpec) {
+        if (this.schema.has(n)) {
+            throw new Error(`Attribute named ${n} already exists in ${this.moduleName}.${this.name}`);
+        }
+        if (attrSpec.properties != undefined) {
+            normalizePropertyNames(attrSpec.properties);
+        }
+        this.schema.set(n, attrSpec);
+        return this;
+    }
+    removeAttribute(n) {
+        this.schema.delete(n);
+        return this;
+    }
+    reorderAttributes(desiredOrder) {
+        this.schema = new Map([...this.schema].sort((a, b) => {
+            return desiredOrder.indexOf(a[0]) - desiredOrder.indexOf(b[0]);
+        }));
+    }
+    addSystemAttribute(n, attrSpec) {
+        setAsSystemAttribute(attrSpec);
+        this.addAttribute(n, attrSpec);
+        return this;
+    }
+    findAttribute(predic) {
+        for (const k of this.schema.keys()) {
+            const attrSpec = this.schema.get(k);
+            if (attrSpec != undefined) {
+                if (predic(attrSpec))
+                    return {
+                        name: k,
+                        spec: attrSpec,
+                    };
+            }
+        }
+        return undefined;
+    }
+    hasRefTo(modName, entryName) {
+        if (this.findAttribute((attrSpec) => {
+            if (attrSpec.properties != undefined) {
+                const ref = attrSpec.properties.get('ref');
+                if (ref != undefined) {
+                    if (ref.getModuleName() == modName && ref.getEntryName() == entryName) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }))
+            return true;
+        else
+            return false;
+    }
+    getIdAttributeName() {
+        const e = this.findAttribute((attrSpec) => {
+            return isIdAttribute(attrSpec);
+        });
+        if (e != undefined) {
+            return e.name;
+        }
+        return undefined;
+    }
+    toString() {
+        if (this.type == RecordType.EVENT && this.meta && this.meta.get(SystemDefinedEvent)) {
+            return '';
+        }
+        let s = `${RecordType[this.type].toLowerCase()} ${this.name}`;
+        if (this.parentEntryName) {
+            s = s.concat(` extends ${this.parentEntryName}`);
+        }
+        const scms = recordSchemaToString(this.schema);
+        return s.concat('\n', scms, '\n');
+    }
+    getUserAttributes() {
+        const recSchema = newRecordSchema();
+        this.schema.forEach((attrSpec, n) => {
+            if (!isSystemAttribute(attrSpec)) {
+                recSchema.set(n, attrSpec);
+            }
+        });
+        return recSchema;
+    }
+    getUserAttributeNames() {
+        return [...this.getUserAttributes().keys()];
+    }
+}
+function fetchModuleByEntryName(entryName, suspectModuleName) {
+    if (isFqName(entryName)) {
+        const path = splitFqName(entryName);
+        entryName = path.getEntryName();
+        suspectModuleName = path.getModuleName();
+    }
+    return {
+        module: fetchModule(suspectModuleName),
+        entryName: entryName,
+        moduleName: suspectModuleName,
+    };
+}
+function cloneParentSchema(parentName, currentModuleName) {
+    const fr = fetchModuleByEntryName(parentName, currentModuleName);
+    parentName = fr.entryName;
+    currentModuleName = fr.moduleName;
+    const mod = fr.module;
+    const entry = mod.getEntry(parentName);
+    const result = newRecordSchema();
+    entry.schema.forEach((attrSpec, attrName) => {
+        result.set(attrName, attrSpec);
+    });
+    return result;
+}
+function asPropertiesMap(props) {
+    if (props != undefined && props.length > 0) {
+        const result = new Map();
+        props.forEach((p) => {
+            const n = p.name.substring(1);
+            if (p.value != undefined && p.value.pairs != undefined && p.value.pairs.length > 0) {
+                if (p.value.pairs.length == 1) {
+                    const kvp = p.value.pairs[0];
+                    if (kvp.key == undefined) {
+                        result.set(n, normalizeKvPairValue(kvp));
+                    }
+                    else {
+                        const v = new Map();
+                        v.set(kvp.key, normalizeKvPairValue(kvp));
+                        result.set(n, v);
+                    }
+                }
+                else {
+                    const v = new Map();
+                    p.value.pairs.forEach((kvp) => {
+                        let k = 'null';
+                        if (kvp.key != undefined)
+                            k = kvp.key;
+                        v.set(k, normalizeKvPairValue(kvp));
+                    });
+                    result.set(n, v);
+                }
+            }
+            else {
+                result.set(n, true);
+            }
+        });
+        return maybeProcessRefProperty(result);
+    }
+    return undefined;
+}
+function maybeProcessRefProperty(props) {
+    const v = props.get('ref');
+    if (v != undefined) {
+        const parts = splitFqName(v);
+        if (!parts.hasModule()) {
+            parts.setModuleName(activeModule);
+        }
+        props.set('ref', parts);
+    }
+    return props;
+}
+function normalizeKvPairValue(kvp) {
+    const v = kvp.value;
+    if (v == undefined)
+        return true;
+    if (v.str != undefined) {
+        return v.str;
+    }
+    else if (v.num != undefined) {
+        return v.num;
+    }
+    else if (v.bool != undefined) {
+        return v.bool;
+    }
+    else if (v.id != undefined) {
+        return v.id;
+    }
+    else if (v.ref != undefined) {
+        return v.ref;
+    }
+    else if (v.fnCall != undefined) {
+        const fncall = v.fnCall;
+        if (fncall.args.length > 0) {
+            throw new Error('Cannot allow arguments in properties function-call');
+        }
+        return fncall.name + '()';
+    }
+    else if (v.array != undefined) {
+        return v.array;
+    }
+    return null;
+}
+export const PlaceholderRecordEntry = new Record('--', DefaultModuleName);
+export var RbacPermissionFlag;
+(function (RbacPermissionFlag) {
+    RbacPermissionFlag[RbacPermissionFlag["CREATE"] = 0] = "CREATE";
+    RbacPermissionFlag[RbacPermissionFlag["READ"] = 1] = "READ";
+    RbacPermissionFlag[RbacPermissionFlag["UPDATE"] = 2] = "UPDATE";
+    RbacPermissionFlag[RbacPermissionFlag["DELETE"] = 3] = "DELETE";
+})(RbacPermissionFlag || (RbacPermissionFlag = {}));
+export class RbacSpecification {
+    constructor() {
+        this.resource = '';
+        this.roles = RbacSpecification.EmptyRoles;
+        this.permissions = new Set();
+    }
+    setResource(s) {
+        this.resource = s;
+        return this;
+    }
+    hasResource() {
+        return this.resource.length > 0;
+    }
+    setPermissions(perms) {
+        perms.forEach((v) => {
+            const idx = v.toUpperCase();
+            const a = RbacPermissionFlag[idx];
+            if (a == undefined) {
+                throw new Error(`Not a valid RBAC permission - ${v}`);
+            }
+            this.permissions.add(a);
+        });
+        return this;
+    }
+    hasPermissions() {
+        return this.permissions.size > 0;
+    }
+    hasCreatePermission() {
+        return this.permissions.has(RbacPermissionFlag.CREATE);
+    }
+    hasReadPermission() {
+        return this.permissions.has(RbacPermissionFlag.READ);
+    }
+    hasUpdatePermission() {
+        return this.permissions.has(RbacPermissionFlag.UPDATE);
+    }
+    hasDeletePermission() {
+        return this.permissions.has(RbacPermissionFlag.DELETE);
+    }
+    setRoles(roles) {
+        if (this.expression) {
+            throw new Error('Cannot set roles while `where` expression is set');
+        }
+        this.roles = new Set();
+        roles.forEach((r) => {
+            this.roles.add(r);
+        });
+        return this;
+    }
+    setExpression(lhs, rhs) {
+        if (this.roles != RbacSpecification.EmptyRoles) {
+            throw new Error('Cannot set `where` expression along with roles');
+        }
+        this.expression = {
+            lhs: lhs,
+            rhs: rhs,
+        };
+        return this;
+    }
+}
+RbacSpecification.EmptyRoles = new Set();
+export class Entity extends Record {
+    constructor(name, moduleName, scm, parentEntryName) {
+        super(name, moduleName, scm, parentEntryName);
+        this.type = RecordType.ENTITY;
+        const idattr = this.getIdAttributeName();
+        if (idattr == undefined) {
+            const attrSpec = {
+                type: 'UUID',
+                properties: new Map().set('default', 'uuid()').set('id', true),
+            };
+            this.schema.set(DefaultIdAttributeName, attrSpec);
+        }
+    }
+    setRbacSpecifications(rbac) {
+        this.rbac = rbac;
+        return this;
+    }
+}
+export class Event extends Record {
+    constructor() {
+        super(...arguments);
+        this.type = RecordType.EVENT;
+    }
+}
+var RelType;
+(function (RelType) {
+    RelType[RelType["CONTAINS"] = 0] = "CONTAINS";
+    RelType[RelType["BETWEEN"] = 1] = "BETWEEN";
+})(RelType || (RelType = {}));
+export function newRelNodeEntry(nodeFqName, alias) {
+    const p = splitFqName(nodeFqName);
+    return {
+        path: p,
+        alias: alias ? alias : p.getEntryName(),
+        origName: nodeFqName,
+        origAlias: alias,
+    };
+}
+function relNodeEntryToString(node) {
+    let n = `${node.origName}`;
+    if (node.origAlias) {
+        n = n.concat(` as ${node.origAlias}`);
+    }
+    return n;
+}
+function asRelNodeEntry(n) {
+    const path = splitFqName(n.name);
+    let modName = activeModule;
+    const entryName = path.getEntryName();
+    if (path.hasModule()) {
+        modName = path.getModuleName();
+    }
+    let alias = entryName;
+    if (n.alias != undefined) {
+        alias = n.alias;
+    }
+    return {
+        path: new Path(modName, entryName),
+        alias: alias,
+        origName: n.name,
+        origAlias: n.alias,
+    };
+}
+export class Relationship extends Record {
+    constructor(name, typ, node1, node2, moduleName, scm, props) {
+        super(name, moduleName, scm);
+        this.type = RecordType.RELATIONSHIP;
+        this.relType = RelType.CONTAINS;
+        if (typ == 'between')
+            this.relType = RelType.BETWEEN;
+        this.node1 = node1;
+        this.node2 = node2;
+        this.properties = props;
+        this.updateSchemaWithNodeAttributes();
+    }
+    updateSchemaWithNodeAttributes() {
+        const attrSpec1 = {
+            type: 'string',
+        };
+        this.addSystemAttribute(this.node1.alias, attrSpec1);
+        const attrSpec2 = {
+            type: 'string',
+        };
+        this.addSystemAttribute(this.node2.alias, attrSpec2);
+        if (this.relType == RelType.BETWEEN && this.isOneToMany()) {
+            const attrSpec3 = {
+                type: 'string',
+                properties: new Map().set('unique', true),
+            };
+            this.addSystemAttribute(this.joinNodesAttributeName(), attrSpec3);
+        }
+    }
+    joinNodesAttributeName() {
+        return this.node1.alias + '_' + this.node2.alias;
+    }
+    setBetweenRef(inst, refPath, isQuery = false) {
+        const refAttrName = `__${this.node1.alias.toLowerCase()}`;
+        if (isQuery) {
+            inst.addQuery(refAttrName, '=', refPath);
+        }
+        else {
+            inst.attributes.set(refAttrName, refPath);
+        }
+    }
+    isContains() {
+        return this.relType == RelType.CONTAINS;
+    }
+    isBetween() {
+        return this.relType == RelType.BETWEEN;
+    }
+    parentNode() {
+        return this.node1;
+    }
+    childNode() {
+        return this.node2;
+    }
+    hasBooleanFlagSet(flag) {
+        if (this.properties != undefined) {
+            return this.properties.get(flag) == true;
+        }
+        return false;
+    }
+    isOneToOne() {
+        return this.isBetween() && this.hasBooleanFlagSet('one_one');
+    }
+    isOneToMany() {
+        return this.isBetween() && this.hasBooleanFlagSet('one_many');
+    }
+    isManyToMany() {
+        if (this.isBetween()) {
+            return (this.hasBooleanFlagSet('many_many') ||
+                (!this.hasBooleanFlagSet('one_one') && !this.hasBooleanFlagSet('one_many')));
+        }
+        else {
+            return false;
+        }
+    }
+    isFirstNode(inst) {
+        return this.isFirstNodeName(inst.getFqName());
+    }
+    getAliasFor(inst) {
+        return this.getAliasForName(inst.getFqName());
+    }
+    getInverseAliasFor(inst) {
+        return this.getInverseAliasForName(inst.getFqName());
+    }
+    isFirstNodeName(fqName) {
+        return fqName == this.node1.path.asFqName();
+    }
+    getAliasForName(fqName) {
+        if (this.isFirstNodeName(fqName)) {
+            return this.node1.alias;
+        }
+        else {
+            return this.node2.alias;
+        }
+    }
+    getInverseAliasForName(fqName) {
+        if (this.isFirstNodeName(fqName)) {
+            return this.node2.alias;
+        }
+        else {
+            return this.node1.alias;
+        }
+    }
+    isParent(inst) {
+        return inst.getFqName() == this.node1.path.asFqName();
+    }
+    getParentFqName() {
+        return this.node1.path.asFqName();
+    }
+    getChildFqName() {
+        return this.node2.path.asFqName();
+    }
+    toString() {
+        const n1 = relNodeEntryToString(this.node1);
+        const n2 = relNodeEntryToString(this.node2);
+        let s = `relationship ${this.name} ${RelType[this.relType].toLowerCase()} (${n1}, ${n2})`;
+        if (this.getUserAttributes().size > 0) {
+            const attrs = [];
+            this.getUserAttributes().forEach((attrSpec, n) => {
+                attrs.push(`${n} ${attributeSpecToString(attrSpec)}`);
+            });
+            s = s.concat(`{\n ${attrs.join(',\n')} }`);
+        }
+        return s.concat('\n');
+    }
+}
+export class Workflow extends ModuleEntry {
+    constructor(name, patterns, moduleName) {
+        super(name, moduleName);
+        this.statements = patterns;
+    }
+    async addStatement(stmtCode) {
+        const result = await parseStatement(stmtCode);
+        this.statements.push(result);
+        return this;
+    }
+    setStatementAtHelper(statements, newStmt, index) {
+        let stmt = statements[index[0]];
+        const isFe = stmt.pattern.forEach;
+        const isIf = stmt.pattern.if;
+        if (isFe || isIf) {
+            for (let i = 1; i < index.length; ++i) {
+                const found = i == index.length - 1;
+                let idx = index[i];
+                if (stmt.pattern.forEach) {
+                    if (found) {
+                        if (!newStmt) {
+                            stmt.pattern.forEach.statements.splice(idx, 1);
+                        }
+                        else {
+                            stmt.pattern.forEach.statements[idx] = newStmt;
+                        }
+                    }
+                    else
+                        stmt = stmt.pattern.forEach.statements[idx];
+                }
+                else if (stmt.pattern.if) {
+                    if (idx < 0 || isMinusZero(idx)) {
+                        if (stmt.pattern.if.else) {
+                            idx *= -1;
+                            if (found) {
+                                if (!newStmt) {
+                                    stmt.pattern.if.else.statements.splice(idx, 1);
+                                }
+                                else {
+                                    stmt.pattern.if.else.statements[idx] = newStmt;
+                                }
+                            }
+                            else
+                                stmt = stmt.pattern.if.else.statements[idx];
+                        }
+                        else {
+                            throw new Error('No else part in if');
+                        }
+                    }
+                    else {
+                        if (found) {
+                            if (!newStmt) {
+                                stmt.pattern.if.statements.splice(idx, 1);
+                            }
+                            else {
+                                stmt.pattern.if.statements[idx] = newStmt;
+                            }
+                        }
+                        else
+                            stmt = stmt.pattern.if.statements[idx];
+                    }
+                }
+                else {
+                    throw new Error('Cannot dig further into statements');
+                }
+            }
+        }
+        return this;
+    }
+    async setStatementAt(stmtCode, index) {
+        const result = await parseStatement(stmtCode);
+        if (index instanceof Array) {
+            if (index.length == 1) {
+                this.statements[index[0]] = result;
+                return this;
+            }
+            else {
+                return this.setStatementAtHelper(this.statements, result, index);
+            }
+        }
+        else {
+            this.statements[index] = result;
+        }
+        return this;
+    }
+    removeStatementAt(index) {
+        if (index instanceof Array) {
+            if (index.length == 1) {
+                this.statements.splice(index[0], 1);
+                return this;
+            }
+            else {
+                return this.setStatementAtHelper(this.statements, undefined, index);
+            }
+        }
+        else {
+            this.statements.splice(index, 1);
+        }
+        return this;
+    }
+    statementsToStringsHelper(statements) {
+        const ss = [];
+        statements.forEach((stmt) => {
+            var _a, _b;
+            if (stmt.pattern.forEach) {
+                ss.push(`   for ${stmt.pattern.forEach.var} in ${(_a = stmt.pattern.forEach.src.$cstNode) === null || _a === void 0 ? void 0 : _a.text} {
+        ${joinStatements(this.statementsToStringsHelper(stmt.pattern.forEach.statements))}
+    }`);
+            }
+            else if (stmt.pattern.if) {
+                let s = `   if (${(_b = stmt.pattern.if.cond.$cstNode) === null || _b === void 0 ? void 0 : _b.text}) {
+        ${joinStatements(this.statementsToStringsHelper(stmt.pattern.if.statements))}
+    }`;
+                if (stmt.pattern.if.else) {
+                    s = s.concat(` else {
+            ${joinStatements(this.statementsToStringsHelper(stmt.pattern.if.else.statements))}
+    }`);
+                }
+                ss.push(s);
+            }
+            else if (stmt.$cstNode) {
+                ss.push(`    ${stmt.$cstNode.text.trimStart()}`);
+            }
+        });
+        return ss;
+    }
+    statementsToStrings() {
+        return this.statementsToStringsHelper(this.statements);
+    }
+    toString() {
+        let s = `workflow ${normalizeWorkflowName(this.name)} {\n`;
+        const ss = this.statementsToStringsHelper(this.statements);
+        s = s.concat(joinStatements(ss));
+        return s.concat('\n}');
+    }
+}
+const EmptyWorkflow = new Workflow('', [], DefaultModuleName);
+export function isEmptyWorkflow(wf) {
+    return wf == EmptyWorkflow;
+}
+export class Module {
+    constructor(name) {
+        this.name = name;
+        this.entries = new Array();
+        this.entriesByTypeCache = null;
+    }
+    addEntry(entry) {
+        this.entries.push(entry);
+        if (this.entriesByTypeCache != null)
+            this.entriesByTypeCache = null;
+        return entry;
+    }
+    getEntryIndex(entryName) {
+        return this.entries.findIndex((v) => {
+            return v.name == entryName;
+        });
+    }
+    hasEntry(entryName) {
+        return this.getEntryIndex(entryName) >= 0;
+    }
+    getEntry(entryName) {
+        const idx = this.getEntryIndex(entryName);
+        if (idx < 0)
+            throw new Error(`Entry ${entryName} not found in module ${this.name}`);
+        return this.entries[idx];
+    }
+    getRecord(recordName) {
+        const e = this.getEntry(recordName);
+        if (e instanceof Record) {
+            return e;
+        }
+        throw new Error(`${recordName} is not a record in module ${this.name}`);
+    }
+    removeEntry(entryName) {
+        const idx = this.getEntryIndex(entryName);
+        if (idx >= 0) {
+            this.entries.splice(idx, 1);
+            if (this.entriesByTypeCache != null)
+                this.entriesByTypeCache = null;
+            return true;
+        }
+        return false;
+    }
+    getEntriesOfType(t) {
+        var _a;
+        if (this.entriesByTypeCache != null && this.entriesByTypeCache.has(t)) {
+            const result = this.entriesByTypeCache.get(t);
+            if (result == undefined)
+                return new Array();
+            return result;
+        }
+        else {
+            const result = this.entries.filter((v) => {
+                const r = v;
+                return r.type == t;
+            });
+            if (this.entriesByTypeCache != null)
+                this.entriesByTypeCache = new Map();
+            (_a = this.entriesByTypeCache) === null || _a === void 0 ? void 0 : _a.set(t, result);
+            return result;
+        }
+    }
+    getEntityEntries() {
+        return this.getEntriesOfType(RecordType.ENTITY);
+    }
+    getEventEntries() {
+        return this.getEntriesOfType(RecordType.EVENT);
+    }
+    getRecordEntries() {
+        return this.getEntriesOfType(RecordType.RECORD);
+    }
+    getRelationshipEntries() {
+        return this.getEntriesOfType(RecordType.RELATIONSHIP);
+    }
+    getRelationshipEntriesOfType(t) {
+        const rels = this.getRelationshipEntries();
+        return rels.filter((e) => {
+            return e.relType == t;
+        });
+    }
+    getBetweenRelationshipEntries() {
+        return this.getRelationshipEntriesOfType(RelType.BETWEEN);
+    }
+    getContainsRelationshipEntries() {
+        return this.getRelationshipEntriesOfType(RelType.CONTAINS);
+    }
+    getBetweenRelationshipEntriesThatNeedStore() {
+        return this.getBetweenRelationshipEntries().filter((re) => {
+            return re.isManyToMany() || re.isOneToMany();
+        });
+    }
+    getWorkflowForEvent(eventName) {
+        return this.getEntry(asWorkflowName(eventName));
+    }
+    isEntryOfType(t, name) {
+        const entry = this.getEntriesOfType(t).find((v) => {
+            const r = v;
+            return r.name == name;
+        });
+        return entry != undefined;
+    }
+    isEntity(name) {
+        return this.isEntryOfType(RecordType.ENTITY, name);
+    }
+    isEvent(name) {
+        return this.isEntryOfType(RecordType.EVENT, name);
+    }
+    isRecord(name) {
+        return this.isEntryOfType(RecordType.RECORD, name);
+    }
+    isRelationship(name) {
+        return this.isEntryOfType(RecordType.RELATIONSHIP, name);
+    }
+    getEntityNames() {
+        const names = [];
+        this.getEntityEntries().forEach((me) => {
+            names.push(me.name);
+        });
+        return names;
+    }
+    getEventNames() {
+        const names = [];
+        this.getEventEntries().forEach((me) => {
+            names.push(me.name);
+        });
+        return names;
+    }
+    getRecordNames() {
+        const names = [];
+        this.getRecordEntries().forEach((me) => {
+            names.push(me.name);
+        });
+        return names;
+    }
+    getRelationshipNames() {
+        const names = [];
+        this.getRelationshipEntries().forEach((me) => {
+            names.push(me.name);
+        });
+        return names;
+    }
+    isContainsRelationship(entryName) {
+        if (this.hasEntry(entryName)) {
+            const entry = this.getEntry(entryName);
+            if (entry instanceof Relationship)
+                return entry.isContains();
+        }
+        return false;
+    }
+    isBetweenRelationship(entryName) {
+        if (this.hasEntry(entryName)) {
+            const entry = this.getEntry(entryName);
+            if (entry instanceof Relationship)
+                return entry.isBetween();
+        }
+        return false;
+    }
+    toString() {
+        const ss = [];
+        this.entries.forEach((me) => {
+            ss.push(me.toString());
+        });
+        return `module ${this.name}\n\n${ss.join('\n')}`;
+    }
+}
+const moduleDb = new Map();
+let activeModule = '';
+export function getActiveModuleName() {
+    return activeModule;
+}
+export function addModule(name) {
+    const mod = new Module(name);
+    moduleDb.set(name, mod);
+    activeModule = name;
+    return mod;
+}
+export function removeModule(name) {
+    if (moduleDb.has(name)) {
+        moduleDb.delete(name);
+        return true;
+    }
+    return false;
+}
+addModule(DefaultModuleName);
+addRecord('env', DefaultModuleName);
+export function getModuleNames() {
+    const ks = moduleDb.keys();
+    return Array.from(ks);
+}
+export function getUserModuleNames() {
+    const result = new Array();
+    Array.from(moduleDb.keys()).forEach((n) => {
+        if (n != DefaultModuleName) {
+            result.push(n);
+        }
+    });
+    return result;
+}
+export function isModule(name) {
+    return moduleDb.has(name);
+}
+export function fetchModule(moduleName) {
+    const module = moduleDb.get(moduleName);
+    if (module == undefined) {
+        throw new Error(`Module not found - ${moduleName}`);
+    }
+    return module;
+}
+export function allModuleNames() {
+    return [...moduleDb.keys()];
+}
+export function fetchModuleEntry(entryName, moduleName) {
+    const module = fetchModule(moduleName);
+    return module.getEntry(entryName);
+}
+const builtInChecks = new Map([
+    ['String', isString],
+    ['Int', Number.isSafeInteger],
+    ['Number', isNumber],
+    ['Email', isString],
+    ['Date', isString],
+    ['Time', isString],
+    ['DateTime', isString],
+    ['Boolean', isBoolean],
+    ['UUID', isString],
+    ['URL', isString],
+    ['Path', isPath],
+    [
+        'Map',
+        (obj) => {
+            return obj instanceof Object || obj instanceof Map;
+        },
+    ],
+    [
+        'Any',
+        (_) => {
+            return true;
+        },
+    ],
+]);
+export const builtInTypes = new Set(Array.from(builtInChecks.keys()));
+export const propertyNames = new Set([
+    '@id',
+    '@indexed',
+    '@default',
+    '@optional',
+    '@unique',
+    '@autoincrement',
+    '@array',
+    '@object',
+    '@fk',
+    '@ref',
+    '@readonly',
+]);
+export function isBuiltInType(type) {
+    return builtInTypes.has(type);
+}
+export function isValidType(type) {
+    if (isBuiltInType(type))
+        return true;
+    const path = splitFqName(type);
+    let modName = '';
+    if (path.hasModule())
+        modName = path.getModuleName();
+    else
+        modName = activeModule;
+    return isModule(modName) && fetchModule(modName).hasEntry(path.getEntryName());
+}
+function checkType(type) {
+    if (type == undefined)
+        throw new Error('Attribute type is required');
+    if (!isValidType(type)) {
+        console.log(chalk.red(`WARN: type not found - ${type}`));
+    }
+}
+function validateProperties(props) {
+    if (props != undefined) {
+        props.forEach((p) => {
+            if (!propertyNames.has(p.name))
+                throw new Error(`Invalid property ${p.name}`);
+        });
+    }
+}
+function verifyAttribute(attr) {
+    if (attr.expr)
+        return;
+    if (!attr.enumSpec && !attr.oneOfSpec && !attr.refSpec)
+        checkType(attr.type || attr.arrayType);
+    validateProperties(attr.properties);
+}
+export function defaultAttributes(schema) {
+    const result = new Map();
+    schema.forEach((v, k) => {
+        const props = v.properties;
+        if (props != undefined) {
+            const d = props.get('default');
+            if (d != undefined) {
+                result.set(k, d);
+            }
+        }
+    });
+    return result;
+}
+export function objectAttributes(schema) {
+    let result;
+    schema.forEach((v, k) => {
+        if (isObjectAttribute(v)) {
+            if (result == undefined)
+                result = new Array();
+            result.push(k);
+        }
+    });
+    return result;
+}
+function getBooleanProperty(propName, attrSpec) {
+    if (attrSpec.properties != undefined) {
+        return attrSpec.properties.get(propName) == true;
+    }
+    return false;
+}
+function getAnyProperty(propName, attrSpec) {
+    if (attrSpec.properties != undefined) {
+        return attrSpec.properties.get(propName);
+    }
+    return undefined;
+}
+export function isIdAttribute(attrSpec) {
+    return getBooleanProperty('id', attrSpec);
+}
+export function isUniqueAttribute(attrSpec) {
+    return getBooleanProperty('unique', attrSpec);
+}
+export function isIndexedAttribute(attrSpec) {
+    return getBooleanProperty('indexed', attrSpec);
+}
+export function isOptionalAttribute(attrSpec) {
+    return getBooleanProperty('optional', attrSpec);
+}
+export function isArrayAttribute(attrSpec) {
+    return getBooleanProperty('array', attrSpec);
+}
+export function isObjectAttribute(attrSpec) {
+    return getBooleanProperty('object', attrSpec);
+}
+export function getAttributeExpr(attrSpec) {
+    return getAnyProperty('expr', attrSpec);
+}
+export function getOneOfValues(attrSpec) {
+    return getAnyProperty('one-of', attrSpec);
+}
+export function getOneOfRef(attrSpec) {
+    return getAnyProperty('one-of-ref', attrSpec);
+}
+export function getAttributeDefaultValue(attrSpec) {
+    return getAnyProperty('default', attrSpec);
+}
+export function getAttributeLength(attrSpec) {
+    return getAnyProperty('length', attrSpec);
+}
+export function getFkSpec(attrSpec) {
+    return getAnyProperty('fk', attrSpec);
+}
+export function getRefSpec(attrSpec) {
+    return getAnyProperty('ref', attrSpec);
+}
+export function addEntity(name, moduleName = activeModule, scm, ext) {
+    const module = fetchModule(moduleName);
+    return module.addEntry(new Entity(name, moduleName, scm, ext));
+}
+export function addEvent(name, moduleName = activeModule, scm, ext) {
+    const module = fetchModule(moduleName);
+    return module.addEntry(new Event(name, moduleName, scm, ext));
+}
+export function addRecord(name, moduleName = activeModule, scm, ext) {
+    const module = fetchModule(moduleName);
+    return module.addEntry(new Record(name, moduleName, scm, ext));
+}
+export function addRelationship(name, type, nodes, moduleName = activeModule, scm, props) {
+    const module = fetchModule(moduleName);
+    let n1;
+    let n2;
+    if (isRelNodes(nodes)) {
+        n1 = asRelNodeEntry(nodes.node1);
+        n2 = asRelNodeEntry(nodes.node2);
+    }
+    else {
+        n1 = nodes[0];
+        n2 = nodes[1];
+    }
+    let propsMap;
+    if (props != undefined)
+        propsMap = asPropertiesMap(props);
+    return module.addEntry(new Relationship(name, type, n1, n2, moduleName, scm, propsMap));
+}
+export function addBetweenRelationship(name, moduleName, nodes) {
+    return addRelationship(name, 'between', nodes, moduleName);
+}
+export function addContainsRelationship(name, moduleName, nodes) {
+    return addRelationship(name, 'contains', nodes, moduleName);
+}
+function asWorkflowName(n) {
+    return n + '--workflow';
+}
+function normalizeWorkflowName(n) {
+    const i = n.indexOf('--workflow');
+    if (i > 0) {
+        return n.substring(0, i);
+    }
+    return n;
+}
+export function addWorkflow(name, moduleName = activeModule, statements) {
+    const module = fetchModule(moduleName);
+    if (module.hasEntry(name)) {
+        const entry = module.getEntry(name);
+        if (!(entry instanceof Event))
+            throw new Error(`Not an event, cannot attach workflow to ${entry.name}`);
+    }
+    else {
+        addEvent(name, moduleName);
+        const event = module.getEntry(name);
+        event.addMeta(SystemDefinedEvent, 'true');
+    }
+    if (!statements)
+        statements = new Array();
+    return module.addEntry(new Workflow(asWorkflowName(name), statements, moduleName));
+}
+export function getWorkflow(eventInstance) {
+    const eventName = eventInstance.name;
+    const moduleName = eventInstance.moduleName;
+    const wfName = asWorkflowName(eventName);
+    const module = fetchModule(moduleName);
+    if (module.hasEntry(wfName)) {
+        return module.getEntry(wfName);
+    }
+    return EmptyWorkflow;
+}
+export function getEntity(name, moduleName) {
+    const fr = fetchModuleByEntryName(name, moduleName);
+    if (fr.module.isEntity(fr.entryName)) {
+        return fr.module.getEntry(fr.entryName);
+    }
+    throw new Error(`Entity ${fr.entryName} not found in module ${fr.moduleName}`);
+}
+export function getEvent(name, moduleName) {
+    const fr = fetchModuleByEntryName(name, moduleName);
+    if (fr.module.isEvent(fr.entryName)) {
+        return fr.module.getEntry(fr.entryName);
+    }
+    throw new Error(`Event ${fr.entryName} not found in module ${fr.moduleName}`);
+}
+export function getRecord(name, moduleName) {
+    const fr = fetchModuleByEntryName(name, moduleName);
+    if (fr.module.isRecord(fr.entryName)) {
+        return fr.module.getEntry(fr.entryName);
+    }
+    throw new Error(`Record ${fr.entryName} not found in module ${fr.moduleName}`);
+}
+export function getRelationship(name, moduleName) {
+    const fr = fetchModuleByEntryName(name, moduleName);
+    if (fr.module.isRelationship(fr.entryName)) {
+        return fr.module.getEntry(fr.entryName);
+    }
+    throw new Error(`Relationship ${fr.entryName} not found in module ${fr.moduleName}`);
+}
+export function getAllBetweenRelationships() {
+    let result = [];
+    allModuleNames().forEach((moduleName) => {
+        const mod = fetchModule(moduleName);
+        result = result.concat(mod.getBetweenRelationshipEntries());
+    });
+    return result;
+}
+export function getAllChildRelationships(parentFqName) {
+    let result = new Array();
+    allModuleNames().forEach((moduleName) => {
+        const mod = fetchModule(moduleName);
+        result = result.concat(mod.getContainsRelationshipEntries().filter((rel) => {
+            return rel.getParentFqName() == parentFqName;
+        }));
+    });
+    return result;
+}
+function filterBetweenRelationshipsForEntity(moduleName, entityName, predic, allBetweenRels) {
+    if (allBetweenRels == undefined) {
+        allBetweenRels = getAllBetweenRelationships();
+    }
+    const p = new Path(moduleName, entityName);
+    return allBetweenRels.filter((re) => {
+        return predic(re, p);
+    });
+}
+export function getAllOneToOneRelationshipsForEntity(moduleName, entityName, allBetweenRels) {
+    return filterBetweenRelationshipsForEntity(moduleName, entityName, (re, p) => {
+        return re.isOneToOne() && (re.node1.path.equals(p) || re.node2.path.equals(p));
+    }, allBetweenRels);
+}
+export function getAllOneToManyRelationshipsForEntity(moduleName, entityName, allBetweenRels) {
+    return filterBetweenRelationshipsForEntity(moduleName, entityName, (re, p) => {
+        return re.isOneToMany() && re.node1.path.equals(p);
+    }, allBetweenRels);
+}
+export function getAllManyToOneRelationshipsForEntity(moduleName, entityName, allBetweenRels) {
+    return filterBetweenRelationshipsForEntity(moduleName, entityName, (re, p) => {
+        return re.isOneToMany() && re.node2.path.equals(p);
+    }, allBetweenRels);
+}
+export function getAllManyToManyRelationshipsForEntity(moduleName, entityName, allBetweenRels) {
+    return filterBetweenRelationshipsForEntity(moduleName, entityName, (re, p) => {
+        return re.isManyToMany() && re.node1.path.equals(p);
+    }, allBetweenRels);
+}
+export function getEntrySchema(name, moduleName) {
+    const m = fetchModule(moduleName);
+    const r = m.getEntry(name);
+    return r.schema;
+}
+export function removeEntity(name, moduleName = activeModule) {
+    const module = fetchModule(moduleName);
+    if (module.isEntity(name)) {
+        return module.removeEntry(name);
+    }
+    return false;
+}
+export function removeRecord(name, moduleName = activeModule) {
+    const module = fetchModule(moduleName);
+    if (module.isRecord(name)) {
+        return module.removeEntry(name);
+    }
+    return false;
+}
+export function removeRelationship(name, moduleName = activeModule) {
+    const module = fetchModule(moduleName);
+    if (module.isRelationship(name)) {
+        return module.removeEntry(name);
+    }
+    return false;
+}
+export function removeWorkflow(name, moduleName = activeModule) {
+    const module = fetchModule(moduleName);
+    return module.removeEntry(asWorkflowName(name));
+}
+export function removeEvent(name, moduleName = activeModule) {
+    const module = fetchModule(moduleName);
+    if (module.isEvent(name)) {
+        const r = module.removeEntry(name);
+        if (r) {
+            module.removeEntry(asWorkflowName(name));
+            return r;
+        }
+    }
+    return false;
+}
+function getAttributeSpec(attrsSpec, attrName) {
+    const spec = attrsSpec.get(attrName);
+    if (spec == undefined) {
+        throw new Error(`Failed to find spec for attribute ${attrName}`);
+    }
+    return spec;
+}
+function checkOneOfValue(attrSpec, attrName, attrValue) {
+    if (getOneOfRef(attrSpec)) {
+        return true;
+    }
+    const vals = getOneOfValues(attrSpec);
+    if (vals) {
+        if (!vals.has(attrValue)) {
+            throw new Error(`Value of ${attrName} must be one-of ${vals}`);
+        }
+        return true;
+    }
+    return false;
+}
+function validateType(attrName, attrValue, attrSpec) {
+    if (attrSpec.type == 'Path') {
+        if (!isPath(attrValue, getRefSpec(attrSpec))) {
+            throw new Error(`Failed to validate Path ${attrValue} passed to ${attrName}`);
+        }
+    }
+    const predic = builtInChecks.get(attrSpec.type);
+    if (predic != undefined) {
+        if (isArrayAttribute(attrSpec)) {
+            if (!(attrValue instanceof Array)) {
+                throw new Error(`${attrName} expects an array of values`);
+            }
+            else {
+                if (!attrValue.every(predic)) {
+                    throw new Error(`Invalid value in the array passed to ${attrName}`);
+                }
+            }
+        }
+        else {
+            if (!checkOneOfValue(attrSpec, attrName, attrValue)) {
+                if (!predic(attrValue)) {
+                    throw new Error(`Invalid value ${attrValue} specified for ${attrName}`);
+                }
+            }
+        }
+    }
+    else {
+        checkOneOfValue(attrSpec, attrName, attrValue);
+    }
+}
+export function newInstanceAttributes() {
+    return new Map();
+}
+const EmptyInstanceAttributes = newInstanceAttributes();
+export class Instance {
+    constructor(record, moduleName, name, attributes, queryAttributes, queryAttributeValues) {
+        this.record = record;
+        this.name = name;
+        this.moduleName = moduleName;
+        this.attributes = attributes;
+        this.queryAttributes = queryAttributes;
+        this.queryAttributeValues = queryAttributeValues;
+    }
+    static EmptyInstance(name, moduleName) {
+        const module = fetchModule(moduleName);
+        return new Instance(module.getEntry(name), moduleName, name, EmptyInstanceAttributes);
+    }
+    static newWithAttributes(inst, newAttrs) {
+        return new Instance(inst.record, inst.moduleName, inst.name, inst.normalizeAttributes(newAttrs));
+    }
+    normalizeAttributes(attrs) {
+        attrs.forEach((v, k) => {
+            const attrSpec = this.record.schema.get(k);
+            if (attrSpec) {
+                if ((isArrayAttribute(attrSpec) || isObjectAttribute(attrSpec)) && isString(v)) {
+                    const obj = JSON.parse(v);
+                    attrs.set(k, obj);
+                }
+            }
+        });
+        return attrs;
+    }
+    requireAudit() {
+        return this.record.getMeta('audit');
+    }
+    lookup(k) {
+        return this.attributes.get(k);
+    }
+    getPath() {
+        return this.lookup(PathAttributeName);
+    }
+    asObject() {
+        const result = new Map();
+        result.set(this.name, Object.fromEntries(this.attributes));
+        return Object.fromEntries(result);
+    }
+    attributesAsObject(stringifyObjects = true) {
+        if (stringifyObjects) {
+            this.attributes.forEach((v, k) => {
+                if (v instanceof Object) {
+                    this.attributes.set(k, JSON.stringify(v instanceof Map ? Object.fromEntries(v) : v));
+                }
+            });
+        }
+        return Object.fromEntries(this.attributes);
+    }
+    queryAttributesAsObject() {
+        if (this.queryAttributes != undefined) {
+            return Object.fromEntries(this.queryAttributes);
+        }
+        return {};
+    }
+    queryAttributeValuesAsObject() {
+        if (this.queryAttributeValues != undefined) {
+            return Object.fromEntries(this.queryAttributeValues);
+        }
+        return {};
+    }
+    addQuery(attrName, op = '=', attrVal = undefined) {
+        if (this.queryAttributes == undefined)
+            this.queryAttributes = newInstanceAttributes();
+        this.queryAttributes.set(attrName, op);
+        if (attrVal != undefined) {
+            if (this.queryAttributeValues == undefined)
+                this.queryAttributeValues = newInstanceAttributes();
+            this.queryAttributeValues.set(attrName, attrVal);
+        }
+    }
+    mergeAttributes(newAttrs) {
+        newAttrs.forEach((v, k) => {
+            this.attributes.set(k, v);
+        });
+        return this;
+    }
+    attachRelatedInstances(relName, insts) {
+        if (this.relatedInstances == undefined) {
+            this.relatedInstances = new Map();
+        }
+        let relInsts = this.relatedInstances.get(relName);
+        if (relInsts == undefined) {
+            relInsts = new Array();
+        }
+        if (insts instanceof Instance) {
+            relInsts.push(insts);
+        }
+        else {
+            insts.forEach((inst) => {
+                relInsts.push(inst);
+            });
+        }
+        this.relatedInstances.set(relName, relInsts);
+        this.attributes.set('->', this.relatedInstances);
+    }
+    detachAllRelatedInstance() {
+        var _a;
+        if (this.relatedInstances != undefined) {
+            (_a = this.relatedInstances) === null || _a === void 0 ? void 0 : _a.clear();
+            this.relatedInstances = undefined;
+            this.attributes.delete('->');
+        }
+    }
+    mergeRelatedInstances() {
+        if (this.relatedInstances != undefined) {
+            this.relatedInstances.forEach((v, k) => {
+                this.attributes.set(k, v);
+            });
+            this.detachAllRelatedInstance();
+        }
+    }
+    getRelatedInstances(relName) {
+        if (this.relatedInstances) {
+            const insts = this.relatedInstances.get(relName);
+            return insts ? insts : undefined;
+        }
+        return undefined;
+    }
+    getAllUserAttributeNames() {
+        return this.record.getUserAttributeNames();
+    }
+    getFqName() {
+        return makeFqName(this.moduleName, this.name);
+    }
+    addContextData(k, v) {
+        if (this.contextData == undefined) {
+            this.contextData = new Map();
+        }
+        this.contextData.set(k, v);
+        return this;
+    }
+    getContextData(k, notFoundValue) {
+        if (this.contextData) {
+            const v = this.contextData.get(k);
+            if (v == undefined)
+                return notFoundValue;
+            return v;
+        }
+        return notFoundValue;
+    }
+    setAuthContext(sesssionInfo) {
+        return this.addContextData('sessionInfo', sesssionInfo);
+    }
+    getAuthContext() {
+        return this.getContextData('sessionInfo', undefined);
+    }
+    getAuthContextUserId() {
+        const sessInfo = this.getContextData('sessionInfo', AdminSession);
+        return sessInfo.userId;
+    }
+    getExprAttributes() {
+        let result;
+        this.record.schema.forEach((attrSpec, n) => {
+            const expr = getAttributeExpr(attrSpec);
+            if (expr) {
+                if (result == undefined) {
+                    result = new Map();
+                }
+                result.set(n, expr);
+            }
+        });
+        return result;
+    }
+    cast() {
+        return Object.fromEntries(this.attributes);
+    }
+    get(k) {
+        return this.attributes.get(k);
+    }
+}
+export function objectAsInstanceAttributes(obj) {
+    const attrs = newInstanceAttributes();
+    Object.entries(obj).forEach((v) => {
+        const obj = v[1];
+        attrs.set(v[0], obj);
+    });
+    return attrs;
+}
+export function findIdAttribute(inst) {
+    const schema = inst.record.schema;
+    for (const [key, value] of schema) {
+        const attrSpec = value;
+        if (isIdAttribute(attrSpec)) {
+            return {
+                name: key,
+                spec: attrSpec,
+            };
+        }
+    }
+    return undefined;
+}
+function maybeSetDefaultAttributeValues(schema, attributes) {
+    const defAttrs = defaultAttributes(schema);
+    defAttrs.forEach((v, k) => {
+        if (!attributes.has(k)) {
+            if (isString(v)) {
+                if (v == 'uuid()') {
+                    v = crypto.randomUUID();
+                }
+                else if (v == 'now()') {
+                    v = now();
+                }
+            }
+            attributes.set(k, v);
+        }
+    });
+    return attributes;
+}
+export function makeInstance(moduleName, entryName, attributes, queryAttributes, queryAttributeValues, queryAll = false) {
+    const module = fetchModule(moduleName);
+    const record = module.getRecord(entryName);
+    const schema = record.schema;
+    if (schema.size > 0) {
+        attributes.forEach((value, key) => {
+            if (!schema.has(key)) {
+                throw new Error(`Invalid attribute ${key} specified for ${moduleName}/${entryName}`);
+            }
+            const spec = getAttributeSpec(schema, key);
+            validateType(key, value, spec);
+        });
+    }
+    if (!queryAttributes && !queryAll) {
+        attributes = maybeSetDefaultAttributeValues(schema, attributes);
+    }
+    return new Instance(record, moduleName, entryName, attributes, queryAttributes, queryAttributeValues);
+}
+export function isEventInstance(inst) {
+    return inst.record.type == RecordType.EVENT;
+}
+export function isEntityInstance(inst) {
+    return inst.record.type == RecordType.ENTITY;
+}
+export function isRecordInstance(inst) {
+    return inst.record.type == RecordType.RECORD;
+}
+export function getAllModuleEntries(f) {
+    const result = new Map();
+    moduleDb.forEach((module, k) => {
+        result.set(k, f(module).map((me) => {
+            return me.name;
+        }));
+    });
+    return result;
+}
+export function getAllEventNames() {
+    return getAllModuleEntries((module) => {
+        return module.getEventEntries();
+    });
+}
+export function getAllEntityNames() {
+    return getAllModuleEntries((module) => {
+        return module.getEntityEntries();
+    });
+}
+export function isBetweenRelationship(relName, moduleName) {
+    const fr = fetchModuleByEntryName(relName, moduleName);
+    const mod = fr.module;
+    return mod.isBetweenRelationship(fr.entryName);
+}
+export function isContainsRelationship(relName, moduleName) {
+    const fr = fetchModuleByEntryName(relName, moduleName);
+    const mod = fr.module;
+    return mod.isContainsRelationship(fr.entryName);
+}
+export function getBetweenInstanceNodeValues(inst) {
+    const re = fetchModuleEntry(inst.name, inst.moduleName);
+    return {
+        node1: inst.attributes.get(re.node1.alias),
+        node2: inst.attributes.get(re.node2.alias),
+        entry: re,
+    };
+}
+export function isInstance(obj) {
+    if (obj) {
+        return obj instanceof Instance;
+    }
+    return false;
+}
+export function isInstanceOfType(obj, fqName) {
+    if (obj) {
+        return isInstance(obj) && fqName == obj.getFqName();
+    }
+    return false;
+}
+export function assertInstance(obj) {
+    if (obj instanceof Array) {
+        if (obj.length == 0) {
+            throw new Error(`Empty instances`);
+        }
+        obj.forEach(assertInstance);
+    }
+    else if (!(obj instanceof Instance)) {
+        throw new Error(`${obj} is not an Instance`);
+    }
+}
+const IsAgentEventMeta = 'is-agent-event';
+const EventAgentName = 'event-agent-name';
+export function defineAgentEvent(moduleName, agentName) {
+    const module = fetchModule(moduleName);
+    const event = new Event(agentName, moduleName);
+    event.addAttribute('message', { type: 'String' });
+    event.addAttribute('chatId', { type: 'String' });
+    event.addMeta(IsAgentEventMeta, 'y');
+    event.addMeta(EventAgentName, agentName);
+    module.addEntry(event);
+}
+export function isTimer(eventInst) {
+    return eventInst.getFqName() == 'agentlang/timer';
+}
+export function isAgentEvent(eventInst) {
+    const flag = eventInst.record.getMeta(IsAgentEventMeta);
+    return flag != undefined && flag == 'y';
+}
+export function eventAgentName(eventInst) {
+    return eventInst.record.getMeta(EventAgentName);
+}
+export function instanceToObject(inst, obj) {
+    inst.attributes.forEach((v, k) => {
+        obj[k] = v;
+    });
+    return obj;
+}
+//# sourceMappingURL=module.js.map