motoko 3.0.0-beta1 → 3.0.0-beta2

package/src/ast.ts

@@ -0,0 +1,69 @@
+export type CompilerAST = CompilerAST[] | CompilerNode | string | null;
+export type CompilerSpan = { name: 'Pos'; args: [string, string, string] };
+
+export interface CompilerNode {
+    name: string;
+    args: CompilerAST[];
+}
+
+export type Span = [number, number];
+export type AST = AST[] | Node | string | null;
+
+export interface Node {
+    name: string;
+    file?: string;
+    start?: Span;
+    end?: Span;
+    type?: Node;
+    args?: AST[];
+}
+
+// export type TypeAST = AST[] | Node | string | number | null;
+// export type TypeNode = {
+//     name: string;
+//     args: TypeAST[];
+// };
+
+export function simplifyAST(ast: CompilerNode): Node;
+export function simplifyAST(ast: CompilerAST[]): AST[];
+export function simplifyAST<T extends CompilerAST>(ast: T): T;
+
+export function simplifyAST(ast: CompilerAST): AST {
+    if (Array.isArray(ast)) {
+        return ast.map((a) => simplifyAST(a));
+    }
+    if (typeof ast !== 'object') {
+        return ast;
+    }
+    if (ast.name === '@') {
+        const [start, end, subAst] = ast.args as [
+            CompilerSpan,
+            CompilerSpan,
+            CompilerAST,
+        ];
+        return {
+            ...(typeof subAst === 'string'
+                ? { name: subAst }
+                : simplifyAST(subAst)),
+            file: start.args[0],
+            start: [+start.args[1], +start.args[2]],
+            end: [+end.args[1], +end.args[2]],
+        };
+    }
+    if (ast.name === ':') {
+        const [type, subAst] = ast.args as [CompilerNode, CompilerAST];
+        // console.log(subAst); ////
+        return {
+            ...(typeof subAst === 'string'
+                ? { name: subAst }
+                : simplifyAST(subAst)),
+            type: simplifyAST(type),
+        };
+    }
+    return {
+        name: ast.name,
+        args: simplifyAST(ast.args),
+    };
+}
+
+// export function getTypeString(type: Type) {}

package/src/file.ts

@@ -60,8 +60,8 @@ export const file = (mo: Motoko, path: string) => {
         parseMotoko() {
             return mo.parseMotoko(result.read());
         },
-        parseMotokoTypes() {
-            return mo.parseMotokoTypes(result.read());
+        parseMotokoTyped() {
+            return mo.parseMotokoTyped(result.read());
         },
         parseCandid() {
             return mo.parseCandid(result.read());

package/src/index.ts

@@ -1,5 +1,12 @@
+import { Node, simplifyAST } from './ast';
 import { file } from './file';
-import { fetchPackage, loadPackages, PackageInfo } from './package';
+import {
+    fetchPackage,
+    installPackages,
+    Package,
+    PackageInfo,
+    validatePackage,
+} from './package';
 import { resolveMain, resolveLib } from './utils/resolveEntryPoint';
 
 export type Motoko = ReturnType<typeof wrapMotoko>;
@@ -22,7 +29,7 @@ export type Diagnostic = {
 export type WasmMode = 'ic' | 'wasi';
 
 export default function wrapMotoko(compiler: Compiler, version: string) {
-    const debug = require('debug')(version ? `motoko:${version}` : 'motoko');
+    const debug = require('debug')(`motoko:${version}`);
 
     const invoke = (key: string, unwrap: boolean, args: any[]) => {
         if (!compiler) {
@@ -87,21 +94,36 @@ export default function wrapMotoko(compiler: Compiler, version: string) {
         list(directory: string): string[] {
             return invoke('readDir', false, [directory]);
         },
-        async fetchPackage(info: string | PackageInfo) {
-            return fetchPackage(info);
-        },
-        async loadPackages(packages: Record<string, string | PackageInfo>) {
-            return loadPackages(mo, packages);
-        },
-        addPackage(name: string, directory: string) {
-            debug('+package', name, directory);
+        async fetchPackage(name:string, info: string | PackageInfo) {
+            if(!info){
+                throw new Error('Please specify both a name and source');
+            }
+            return fetchPackage(name,info);
+        },
+        async installPackages(packages: Record<string, string | PackageInfo>) {
+            return installPackages(mo, packages);
+        },
+        loadPackage(pkg: Package) {
+            debug('+package', pkg.name);
+            mo.validatePackage(pkg);
+            const directory = `.node-motoko/${pkg.name}/${pkg.version}`;
+            Object.entries(pkg.files).forEach(([path, file]) => {
+                mo.write(`${directory}/${path}`, file.content);
+            });
+            mo.usePackage(pkg.name, directory);
+        },
+        usePackage(name: string, directory: string) {
+            debug('@package', name, directory);
             invoke('addPackage', false, [name, directory]);
         },
         clearPackages() {
             debug('-packages');
             invoke('clearPackage', false, []);
         },
-        setAliases(aliases: string) {
+        validatePackage(pkg: Package) {
+            validatePackage(pkg);
+        },
+        setAliases(aliases: Record<string, string>) {
             debug('aliases', aliases);
             invoke('setActorAliases', false, [Object.entries(aliases)]);
         },
@@ -129,11 +151,16 @@ export default function wrapMotoko(compiler: Compiler, version: string) {
             }
             return invoke('compileWasm', true, [mode, path]);
         },
-        parseMotoko(content: string): object {
-            return invoke('parseMotoko', true, [content]);
+        parseMotoko(content: string): Node {
+            const ast = invoke('parseMotoko', true, [content]);
+            return simplifyAST(ast);
         },
-        parseMotokoTypes(content: string): { ast: object; outputType: object } {
-            return invoke('parseMotokoTypes', true, [content]);
+        parseMotokoTyped(content: string): { ast: Node; type: Node } {
+            const { ast, typ } = invoke('parseMotokoTyped', true, [content]);
+            return {
+                ast: simplifyAST(ast),
+                type: simplifyAST(typ),
+            };
         },
         parseCandid(content: string): object {
             return invoke('parseCandid', true, [content]);

package/src/package.ts

@@ -4,6 +4,7 @@
 import { default as parse } from 'isomorphic-parse-github-url';
 import fetch from 'cross-fetch';
 import { Motoko } from '.';
+import sanitize from 'sanitize-filename';
 
 export interface PackageInfo {
     name: string;
@@ -42,7 +43,7 @@ async function loadPackage(mo: Motoko, info: PackageInfo) {
     };
     const result = await fetchGithub_(mo, repo, info.name);
     if (result) {
-        mo.addPackage(info.name, info.name + '/');
+        mo.usePackage(info.name, info.name + '/');
     }
     return result ? true : false;
 }
@@ -279,6 +280,7 @@ async function fetchFromService(
 }
 
 export async function fetchPackage(
+    name: string,
     info: string | PackageInfo,
 ): Promise<Package | undefined> {
     if (typeof info === 'string') {
@@ -289,13 +291,13 @@ export async function fetchPackage(
         return;
     }
     return {
-        name: info.name,
+        name,
         version: info.version,
         files,
     };
 }
 
-export async function loadPackages(
+export async function installPackages(
     mo: Motoko,
     packages: Record<string, string | PackageInfo>,
 ) {
@@ -309,3 +311,54 @@ export async function loadPackages(
         }),
     );
 }
+
+export function validatePackage(pkg: Package) {
+    function showValue(value: any) {
+        const string = JSON.stringify(value);
+        return string.length > 50 ? string.substring(0, 50) + '...' : string;
+    }
+    function getPackageDisplayName() {
+        return `(${pkg.name} / ${pkg.version})`;
+    }
+
+    if (typeof pkg !== 'object' || Array.isArray(pkg)) {
+        throw new Error(`Unexpected package: ${showValue(pkg)}`);
+    }
+    if (typeof pkg.name !== 'string' || sanitize(pkg.name) !== pkg.name) {
+        throw new Error(`Invalid package name ${getPackageDisplayName()}`);
+    }
+    if (
+        typeof pkg.version !== 'string' ||
+        sanitize(pkg.version) !== pkg.version
+    ) {
+        throw new Error(`Invalid package version ${getPackageDisplayName()}`);
+    }
+    if (typeof pkg.files !== 'object' || Array.isArray(pkg.files)) {
+        throw new Error(`Invalid package files: ${showValue(pkg.files)}`);
+    }
+
+    Object.entries(pkg.files).forEach(([path, file]) => {
+        if (
+            typeof path !== 'string' ||
+            path.split('/').some((p) => sanitize(p) !== p)
+        ) {
+            throw new Error(
+                `Invalid file path ${getPackageDisplayName()} [${path}]`,
+            );
+        }
+        if (typeof file !== 'object' || Array.isArray(file)) {
+            throw new Error(
+                `Invalid file ${getPackageDisplayName()} [${path}]: ${showValue(
+                    file,
+                )}`,
+            );
+        }
+        if (typeof file.content !== 'string') {
+            throw new Error(
+                `Invalid file content ${getPackageDisplayName()} [${path}]: ${showValue(
+                    file.content,
+                )}`,
+            );
+        }
+    });
+}

package/src/utils/resolveEntryPoint.ts

@@ -55,10 +55,10 @@ function resolveEntryPoint(
     // return getOne(parsedFiles.filter());
 }
 
-export function resolveMain(mo: Motoko, directory: string): string | undefined {
+export function resolveMain(mo: Motoko, directory: string): string {
     return resolveEntryPoint(mo, directory, 'Main.mo');
 }
 
-export function resolveLib(mo: Motoko, directory: string): string | undefined {
+export function resolveLib(mo: Motoko, directory: string): string {
     return resolveEntryPoint(mo, directory, 'Lib.mo');
 }