nesoi 3.0.0

package/lib/compiler/typescript/bridge/organize.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSBridgeOrganize = void 0;
+const dependency_1 = require("../../../engine/dependency");
+class TSBridgeOrganize {
+    static functions(types = [], functions = []) {
+        const organized = {
+            buckets: {},
+            messages: {},
+            jobs: {},
+            machines: {}
+        };
+        functions.forEach(fn => {
+            const match = fn.path.match(/(\w+::\w+:.+?)▹(.+)/);
+            if (!match)
+                return;
+            const [_, tag, path] = match;
+            const { type } = dependency_1.$Tag.parseOrFail(tag);
+            if (type === 'bucket') {
+                this.bucket(organized, tag, path, fn.node);
+            }
+            else if (type === 'message') {
+                this.message(organized, tag, path, fn.node);
+            }
+            else if (type === 'job') {
+                this.job(organized, tag, path, fn.node);
+            }
+            else if (type === 'resource') {
+                this.resource(organized, tag, path, fn.node);
+            }
+            else if (type === 'machine') {
+                this.machine(organized, tag, path, fn.node);
+            }
+        });
+        types.forEach(_type => {
+            const match = _type.path.match(/(\w+::\w+:.+?)▹(.+)/);
+            if (!match)
+                return;
+            const [_, tag, path] = match;
+            const { type } = dependency_1.$Tag.parseOrFail(tag);
+            if (type === 'job') {
+                this.type_job(organized, tag, path, _type.type);
+            }
+        });
+        return organized;
+    }
+    static bucket(organized, tag, path, node) {
+        var _a, _b;
+        const viewComputed = path.match(/view▹(\w+)▹1▹return▹([\w|\\.]+)▹computed▹0/);
+        if (viewComputed) {
+            const [_, view, prop] = viewComputed;
+            (_a = organized.buckets)[tag] ?? (_a[tag] = { views: {} });
+            (_b = organized.buckets[tag].views)[view] ?? (_b[view] = { computed: {} });
+            organized.buckets[tag].views[view].computed[prop] = node;
+            return;
+        }
+    }
+    static message(organized, tag, path, node) {
+        var _a, _b;
+        const rule = path.match(/template▹0▹return▹([\w|\\.]+)▹rule▹0/);
+        if (rule) {
+            const [_, prop] = rule;
+            (_a = organized.messages)[tag] ?? (_a[tag] = { rules: {} });
+            (_b = organized.messages[tag].rules)[prop] ?? (_b[prop] = []);
+            organized.messages[tag].rules[prop].push(node);
+            return;
+        }
+    }
+    static inlineMessage(organized, parentTag, path, node) {
+        const message = path.match(/messages▹0▹return▹([\w|\\.]*)▹(.*)/);
+        if (message) {
+            const [_, inlineName, path] = message;
+            const parent = dependency_1.$Tag.parseOrFail(parentTag);
+            const msgName = inlineName.length ? `${parent.name}.${inlineName}` : parent.name;
+            const msgTag = `${parent.module}::message:${msgName}`;
+            const templatePath = `template▹0▹return▹${path}`;
+            this.message(organized, msgTag, templatePath, node);
+            return;
+        }
+    }
+    static inputMessage(organized, parentTag, path, node) {
+        const message = path.match(/input▹0▹return▹(.*)/);
+        if (message) {
+            const [_, path] = message;
+            const parent = dependency_1.$Tag.parseOrFail(parentTag);
+            const msgTag = `${parent.module}::message:${parent.name}`;
+            const templatePath = `template▹0▹return▹${path}`;
+            this.message(organized, msgTag, templatePath, node);
+            return;
+        }
+    }
+    static job(organized, tag, path, node) {
+        var _a, _b, _c, _d, _e;
+        this.inlineMessage(organized, tag, path, node);
+        const extra = path.match(/extra▹0/);
+        if (extra) {
+            (_a = organized.jobs)[tag] ?? (_a[tag] = {});
+            (_b = organized.jobs[tag]).extrasAndAsserts ?? (_b.extrasAndAsserts = []);
+            organized.jobs[tag].extrasAndAsserts.push({ extra: node });
+            return;
+        }
+        const assert = path.match(/assert▹0/);
+        if (assert) {
+            (_c = organized.jobs)[tag] ?? (_c[tag] = {});
+            (_d = organized.jobs[tag]).extrasAndAsserts ?? (_d.extrasAndAsserts = []);
+            organized.jobs[tag].extrasAndAsserts.push({ assert: node });
+            return;
+        }
+        const method = path.match(/method▹0/);
+        if (method) {
+            (_e = organized.jobs)[tag] ?? (_e[tag] = {});
+            organized.jobs[tag].method = node;
+            return;
+        }
+    }
+    static type_job(organized, tag, path, type) {
+        var _a;
+        const raw = path.match(/output▹raw/);
+        if (raw) {
+            (_a = organized.jobs)[tag] ?? (_a[tag] = {});
+            organized.jobs[tag].outputRaw = type;
+            return;
+        }
+    }
+    static resourceJob(organized, tag, path, node) {
+        var _a, _b, _c, _d, _e, _f;
+        this.inputMessage(organized, tag, path, node);
+        const extra = path.match(/extra▹0/);
+        if (extra) {
+            (_a = organized.jobs)[tag] ?? (_a[tag] = {});
+            (_b = organized.jobs[tag]).extrasAndAsserts ?? (_b.extrasAndAsserts = []);
+            organized.jobs[tag].extrasAndAsserts.push({ extra: node });
+            return;
+        }
+        const assert = path.match(/assert▹0/);
+        if (assert) {
+            (_c = organized.jobs)[tag] ?? (_c[tag] = { extrasAndAsserts: [] });
+            (_d = organized.jobs[tag]).extrasAndAsserts ?? (_d.extrasAndAsserts = []);
+            organized.jobs[tag].extrasAndAsserts.push({ assert: node });
+            return;
+        }
+        const prepare = path.match(/prepare▹0/);
+        if (prepare) {
+            (_e = organized.jobs)[tag] ?? (_e[tag] = { extrasAndAsserts: [] });
+            organized.jobs[tag].prepare = node;
+            return;
+        }
+        const after = path.match(/after▹0/);
+        if (after) {
+            (_f = organized.jobs)[tag] ?? (_f[tag] = { extrasAndAsserts: [] });
+            organized.jobs[tag].after = node;
+            return;
+        }
+    }
+    static resource(organized, tag, path, node) {
+        const job = path.match(/(create|update|delete)▹0▹return▹(.*)/);
+        if (job) {
+            const [_, method, path] = job;
+            const resource = dependency_1.$Tag.parseOrFail(tag);
+            const jobName = `${resource.name}.${method}`;
+            const jobTag = `${resource.module}::job:${jobName}`;
+            this.resourceJob(organized, jobTag, path, node);
+            return;
+        }
+    }
+    static machine(organized, tag, path, node) {
+        this.inlineMessage(organized, tag, path, node);
+        const state = path.match(/((state▹\w+▹1▹return▹)+)(.*)/);
+        if (state) {
+            const [_, bigStatePath, _2, deepPath] = state;
+            const statePath = bigStatePath.matchAll(/state▹(\w+)▹1▹return▹/g);
+            const sName = [];
+            for (const p of statePath)
+                sName.push(p[1]);
+            const stateName = sName.join('.');
+            this.machineState(organized, tag, stateName, deepPath, node);
+            return;
+        }
+    }
+    static machineState(organized, machineTag, stateName, path, node) {
+        var _a, _b;
+        const machine = dependency_1.$Tag.parseOrFail(machineTag);
+        const job = path.match(/(beforeEnter|afterEnter|beforeLeave|afterLeave)▹0▹return▹(.*)/);
+        if (job) {
+            const [_, moment, path] = job;
+            const _moment = moment;
+            const suffix = {
+                beforeEnter: '__before_enter',
+                afterEnter: '__after_enter',
+                beforeLeave: '__before_leave',
+                afterLeave: '__after_leave',
+            }[_moment];
+            const jobName = `${machine.name}@${stateName}${suffix}`;
+            const jobTag = `${machine.module}::job:${jobName}`;
+            this.job(organized, jobTag, path, node);
+        }
+        const beforeEnter = path.match(/beforeEnter▹0▹return/);
+        if (beforeEnter) {
+            const jobName = `${machine.name}@${stateName}__before_enter`;
+            const jobTag = `${machine.module}::job:${jobName}`;
+            this.job(organized, jobTag, path, node);
+        }
+        const afterEnter = path.match(/afterEnter▹0▹return/);
+        if (afterEnter) {
+            const jobName = `${machine.name}@${stateName}__after_enter`;
+            const jobTag = `${machine.module}::job:${jobName}`;
+            this.job(organized, jobTag, path, node);
+        }
+        const beforeLeave = path.match(/beforeLeave▹0▹return/);
+        if (beforeLeave) {
+            const jobName = `${machine.name}@${stateName}__before_leave`;
+            const jobTag = `${machine.module}::job:${jobName}`;
+            this.job(organized, jobTag, path, node);
+        }
+        const afterLeave = path.match(/afterLeave▹0▹return/);
+        if (afterLeave) {
+            const jobName = `${machine.name}@${stateName}__after_leave`;
+            const jobTag = `${machine.module}::job:${jobName}`;
+            this.job(organized, jobTag, path, node);
+        }
+        const transition = path.match(/transition▹([\w|\\.|@]+)▹1▹return▹(.*)/);
+        if (transition) {
+            const [_, msg, path] = transition;
+            (_a = organized.machines)[machineTag] ?? (_a[machineTag] = { states: {} });
+            (_b = organized.machines[machineTag].states)[stateName] ?? (_b[stateName] = {});
+            const extract = organized.machines[machineTag].states[stateName];
+            this.machineTransition(organized, extract, machineTag, stateName, msg, path, node);
+        }
+    }
+    static machineTransition(organized, extract, machineTag, stateName, msg, path, node) {
+        var _a;
+        const machine = dependency_1.$Tag.parseOrFail(machineTag);
+        if (msg.startsWith('@.')) {
+            msg = msg.replace('@', machine.name);
+        }
+        const elses = path.matchAll(/else▹0▹return▹/g);
+        let nElses = 0;
+        for (const _ of elses)
+            nElses++;
+        extract.transitions ?? (extract.transitions = {});
+        (_a = extract.transitions)[msg] ?? (_a[msg] = []);
+        const trans = extract.transitions[msg];
+        if (trans.length < nElses) {
+            trans.push(...Array(nElses - trans.length).map(() => ({})));
+        }
+        const condition = path.match(/if▹0$/);
+        if (condition) {
+            trans[nElses].if = node;
+        }
+        const job = path.match(/runJob▹0▹return/);
+        if (job) {
+            const jobName = `${machine.name}@${stateName}~${msg}#${nElses}`;
+            const jobTag = `${machine.module}::job:${jobName}`;
+            this.job(organized, jobTag, path, node);
+        }
+    }
+}
+exports.TSBridgeOrganize = TSBridgeOrganize;

package/lib/compiler/typescript/error.d.ts

@@ -0,0 +1,88 @@
+import * as ts from 'typescript';
+export declare class MetaError extends Error {
+    constructor(message: string);
+    static DirectoryDoesntExists(dir: string): MetaError;
+    static FileDoesntExist(path: string): MetaError;
+    static NoModulesFolder(): MetaError;
+}
+export declare class ParserError extends Error {
+    constructor(message: string);
+    static ObjectPropertyIsNotAssignment(): MetaError;
+    static StrangeValueKind(kind: ts.SyntaxKind): void;
+    static StrangeTypeKind(kind: ts.SyntaxKind): void;
+}
+export declare class ConstParserError extends Error {
+    constructor(message: string);
+    static ConstValueIsWrongKind(kind: string): void;
+    static ConstValueIsStrange(): void;
+    static ConstEnumIsWrongKind(kind: string): void;
+    static ConstEnumReturnIsWrongKind(kind: string): void;
+    static ConstEnumOptionIsWrongKind(kind: string): void;
+    static ConstEnumOptionIsStrange(): void;
+}
+export declare class ControllerParserError extends Error {
+    constructor(message: string);
+    static ControllerIsWrongKind(kind: string): void;
+    static ControllerEndpointIsWrongKind(kind: string): void;
+    static ControllerEndpointDefIsWrongKind(kind: string): void;
+    static ControllerEndpointHasNoName(): void;
+    static ControllerEndpointHasNoMessage(): void;
+    static ControllerGroupIsWrongKind(kind: string): void;
+    static ControllerGroupHasNoName(): void;
+    static ControllerGroupDefIsWrongKind(kind: string): void;
+}
+export declare class MsgParserError extends Error {
+    constructor(message: string);
+    static MessageHasNoTemplate(): void;
+    static MessageTemplateIsWrongKind(kind: string): void;
+    static MessageTemplateFieldIsWrongKind(kind: string): void;
+    static MessageTemplateFieldHasNoType(): void;
+    static MessageMultiTemplateIsWrongKind(kind: string): void;
+    static MessageTemplateFieldEnumIsWrongKind(kind: string): void;
+}
+export declare class EnumParserError extends Error {
+    constructor(message: string);
+    static ModelFieldEnumIsWrongKind(kind: string): void;
+}
+export declare class BucketParserError extends Error {
+    constructor(message: string);
+    static BucketHasNoModel(): void;
+    static BucketModelIsWrongKind(kind: string): void;
+    static BucketModelFieldIsWrongKind(kind: string): void;
+    static BucketModelFieldHasNoType(): void;
+    static BucketHasNoGraph(): void;
+    static BucketGraphIsWrongKind(kind: string): void;
+    static BucketGraphLinkIsWrongKind(kind: string): void;
+    static BucketGraphLinkHasNoType(): void;
+    static BucketGraphLinkInvalid(): void;
+    static BucketHasNoView(): void;
+    static BucketViewHasNoTemplate(): void;
+    static BucketViewIsWrongKind(kind: string): void;
+    static BucketViewFieldIsWrongKind(kind: string): void;
+    static BucketViewFieldHasNoType(): void;
+    static BucketViewFieldInvalid(): void;
+}
+export declare class JobParserError extends Error {
+    constructor(message: string);
+    static JobHasNoTemplate(): void;
+    static JobTemplateIsWrongKind(kind: string): void;
+    static JobTemplateFieldIsWrongKind(kind: string): void;
+    static JobTemplateFieldHasNoType(): void;
+    static JobAuthnHasInvalidValue(): void;
+}
+export declare class ResourceParserError extends Error {
+    constructor(message: string);
+    static ResourceJobInputHasNoTemplate(): void;
+}
+export declare class HelperError extends Error {
+    constructor(message: string);
+    static ArrayElementIsNotString(kind: string): void;
+    static NotAStringOrArray(kind: string): void;
+    static StringIsUndefined(): void;
+    static NotAString(kind: string): void;
+}
+export declare class TypegenError extends Error {
+    constructor(message: string);
+    static BuildMethodNotCalled(context: string): MetaError;
+    static Resource_BucketRequired(context: string): MetaError;
+}

package/lib/compiler/typescript/error.js

@@ -0,0 +1,265 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypegenError = exports.HelperError = exports.ResourceParserError = exports.JobParserError = exports.BucketParserError = exports.EnumParserError = exports.MsgParserError = exports.ControllerParserError = exports.ConstParserError = exports.ParserError = exports.MetaError = void 0;
+const ts = __importStar(require("typescript"));
+class MetaError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static DirectoryDoesntExists(dir) {
+        return new MetaError(`Directory doesnt exists: ${dir}.`);
+    }
+    static FileDoesntExist(path) {
+        return new MetaError(`File doesn't exist: ${path}`);
+    }
+    static NoModulesFolder() {
+        return new MetaError('No modules folder found on project root.');
+    }
+}
+exports.MetaError = MetaError;
+class ParserError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static ObjectPropertyIsNotAssignment() {
+        return new MetaError('Object property is not an assignment.');
+    }
+    static StrangeValueKind(kind) {
+        throw new MetaError(`Strange value kind ${ts.SyntaxKind[kind]}`);
+    }
+    static StrangeTypeKind(kind) {
+        throw new MetaError(`Strange type kind ${ts.SyntaxKind[kind]}`);
+    }
+}
+exports.ParserError = ParserError;
+class ConstParserError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static ConstValueIsWrongKind(kind) {
+        throw new MetaError(`Constant value is of wrong kind (${kind})`);
+    }
+    static ConstValueIsStrange() {
+        throw new MetaError('Constant value should be $.static or $.app');
+    }
+    static ConstEnumIsWrongKind(kind) {
+        throw new MetaError(`Constant enum is of wrong kind (${kind})`);
+    }
+    static ConstEnumReturnIsWrongKind(kind) {
+        throw new MetaError(`Constant enum return is of wrong kind (${kind})`);
+    }
+    static ConstEnumOptionIsWrongKind(kind) {
+        throw new MetaError(`Constant enum option is of wrong kind (${kind})`);
+    }
+    static ConstEnumOptionIsStrange() {
+        throw new MetaError('Constant enum option should be $.opt');
+    }
+}
+exports.ConstParserError = ConstParserError;
+class ControllerParserError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static ControllerIsWrongKind(kind) {
+        throw new MetaError(`Controller is of wrong kind (${kind})`);
+    }
+    static ControllerEndpointIsWrongKind(kind) {
+        throw new MetaError(`Controller endpoint is of wrong kind (${kind})`);
+    }
+    static ControllerEndpointDefIsWrongKind(kind) {
+        throw new MetaError(`Controller endpoint def is of wrong kind (${kind})`);
+    }
+    static ControllerEndpointHasNoName() {
+        throw new MetaError('Controller endpoint has no name');
+    }
+    static ControllerEndpointHasNoMessage() {
+        throw new MetaError('Controller endpoint declares no .msg()');
+    }
+    static ControllerGroupIsWrongKind(kind) {
+        throw new MetaError(`Controller group is of wrong kind (${kind})`);
+    }
+    static ControllerGroupHasNoName() {
+        throw new MetaError('Controller group has no name');
+    }
+    static ControllerGroupDefIsWrongKind(kind) {
+        throw new MetaError(`Controller group def is of wrong kind (${kind})`);
+    }
+}
+exports.ControllerParserError = ControllerParserError;
+class MsgParserError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static MessageHasNoTemplate() {
+        throw new MetaError('Message has no template');
+    }
+    static MessageTemplateIsWrongKind(kind) {
+        throw new MetaError(`Message template is of wrong kind (${kind})`);
+    }
+    static MessageTemplateFieldIsWrongKind(kind) {
+        throw new MetaError(`Message template field is of wrong kind (${kind})`);
+    }
+    static MessageTemplateFieldHasNoType() {
+        throw new MetaError('Message template field has no type');
+    }
+    static MessageMultiTemplateIsWrongKind(kind) {
+        throw new MetaError(`Message multi template is of wrong kind (${kind})`);
+    }
+    static MessageTemplateFieldEnumIsWrongKind(kind) {
+        throw new MetaError(`Message template field enum is of wrong kind (${kind})`);
+    }
+}
+exports.MsgParserError = MsgParserError;
+class EnumParserError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static ModelFieldEnumIsWrongKind(kind) {
+        throw new MetaError(`Model field enum is of wrong kind (${kind})`);
+    }
+}
+exports.EnumParserError = EnumParserError;
+class BucketParserError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static BucketHasNoModel() {
+        throw new MetaError('Bucket has no model');
+    }
+    static BucketModelIsWrongKind(kind) {
+        throw new MetaError(`Bucket model is of wrong kind (${kind})`);
+    }
+    static BucketModelFieldIsWrongKind(kind) {
+        throw new MetaError(`Bucket model field is of wrong kind (${kind})`);
+    }
+    static BucketModelFieldHasNoType() {
+        throw new MetaError('Bucket model field has no type');
+    }
+    static BucketHasNoGraph() {
+        throw new MetaError('Bucket has no graph');
+    }
+    static BucketGraphIsWrongKind(kind) {
+        throw new MetaError(`Bucket graph is of wrong kind (${kind})`);
+    }
+    static BucketGraphLinkIsWrongKind(kind) {
+        throw new MetaError(`Bucket graph field is of wrong kind (${kind})`);
+    }
+    static BucketGraphLinkHasNoType() {
+        throw new MetaError('Bucket graph field has no type');
+    }
+    static BucketGraphLinkInvalid() {
+        throw new MetaError('Bucket graph link is invalid');
+    }
+    static BucketHasNoView() {
+        throw new MetaError('Bucket has no view');
+    }
+    static BucketViewHasNoTemplate() {
+        throw new MetaError('Bucket view has no template');
+    }
+    static BucketViewIsWrongKind(kind) {
+        throw new MetaError(`Bucket view is of wrong kind (${kind})`);
+    }
+    static BucketViewFieldIsWrongKind(kind) {
+        throw new MetaError(`Bucket view field is of wrong kind (${kind})`);
+    }
+    static BucketViewFieldHasNoType() {
+        throw new MetaError('Bucket view field has no type');
+    }
+    static BucketViewFieldInvalid() {
+        throw new MetaError('Bucket view field is invalid');
+    }
+}
+exports.BucketParserError = BucketParserError;
+class JobParserError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static JobHasNoTemplate() {
+        throw new MetaError('Job has no template');
+    }
+    static JobTemplateIsWrongKind(kind) {
+        throw new MetaError(`Job template is of wrong kind (${kind})`);
+    }
+    static JobTemplateFieldIsWrongKind(kind) {
+        throw new MetaError(`Job template field is of wrong kind (${kind})`);
+    }
+    static JobTemplateFieldHasNoType() {
+        throw new MetaError('Job template field has no type');
+    }
+    static JobAuthnHasInvalidValue() {
+        throw new MetaError('Job authn has invalid value');
+    }
+}
+exports.JobParserError = JobParserError;
+class ResourceParserError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static ResourceJobInputHasNoTemplate() {
+        throw new MetaError('Resource job input has no template');
+    }
+}
+exports.ResourceParserError = ResourceParserError;
+class HelperError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static ArrayElementIsNotString(kind) {
+        throw new MetaError(`Array element is not a string (${kind})`);
+    }
+    static NotAStringOrArray(kind) {
+        throw new MetaError(`Not a string or array (${kind})`);
+    }
+    static StringIsUndefined() {
+        throw new MetaError('String is undefined');
+    }
+    static NotAString(kind) {
+        throw new MetaError(`Not a string (${kind})`);
+    }
+}
+exports.HelperError = HelperError;
+class TypegenError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static BuildMethodNotCalled(context) {
+        return new MetaError(`Build method not called on ${context}.`);
+    }
+    static Resource_BucketRequired(context) {
+        return new MetaError(`Resource ${context} should specify a bucket.`);
+    }
+}
+exports.TypegenError = TypegenError;

package/lib/compiler/typescript/parser.d.ts

@@ -0,0 +1,48 @@
+import * as ts from 'typescript';
+export type ParsedType = string | ({
+    [x: string]: ParsedType;
+} & {
+    __array?: boolean;
+    __optional?: boolean;
+});
+export declare class ParsedNode {
+    superkind: 'value' | 'type';
+    kind: 'primitive' | 'string' | 'obj' | 'array' | 'fn' | 'identifier' | 'call' | 'chain' | 'expression' | 'token';
+    value: any;
+    type: string;
+    expressionOperator?: ParsedNode;
+    arrayElement?: ParsedNode;
+    arguments?: ParsedNode[];
+    members?: ParsedNodes;
+    return?: ParsedNode;
+    chain?: ParsedNode[];
+    constructor(node: ts.Node, superkind: 'value' | 'type', kind: 'primitive' | 'string' | 'obj' | 'array' | 'fn' | 'identifier' | 'call' | 'chain' | 'expression' | 'token', value: any, type?: string);
+    withExpressionOperator(operator: ParsedNode): this;
+    withArrayElement(element: ParsedNode): this;
+    withArguments(args: ParsedNode[]): this;
+    withMembers(members: ParsedNodes): this;
+    withReturn(node: ParsedNode): this;
+    withChain(chain: ParsedNode[]): this;
+    toString(d?: number): string | undefined;
+}
+export type ParsedNodes = {
+    [x: string]: ParsedNode;
+};
+export declare class Parser {
+    static parseNode<T extends ts.Node | undefined>(node?: T, parseChain?: boolean): undefined extends T ? undefined : ParsedNode;
+    private static parseObjectMembers;
+    private static parseArrayElements;
+    private static parseFunctionName;
+    private static parseFunctionParameters;
+    private static parseBlockReturn;
+    private static parseFunctionCall;
+    private static parseGetterCall;
+    private static parseCallArguments;
+    private static parsePrefixUnaryExpression;
+    private static parseAwaitExpression;
+    private static parseBinaryExpression;
+    private static parseConditionalExpression;
+    private static parseCallChain;
+    static parseType<T extends ts.Node | undefined>(node?: T): undefined extends T ? undefined : ParsedNode;
+    private static parseTypeMembers;
+}