@naanlang/naan 1.0.6 → 1.0.8

package/plugins/serviceYC/naanide-relay-index.js

@@ -0,0 +1,148 @@
+/*
+ * index.js
+ * naanide-relay
+ * 
+ * Yandex Cloud Function for proxying API requests from NaanIDE in the browser.
+ *
+ * This function acts as a relay (mitm) proxy so that a browser may access Yandex Cloud APIs without
+ * needing a transient access token and without CORS problems. Security is provided by a pre-shared
+ * static key, configured as an environment variable in the YCF and known to the browser code.
+ *
+ * The request to the proxy should be precisely what is intended for the target API, except that the
+ * following headers should be included:
+ *
+ *      x-naanide-auth:     <pre-shared-key>
+ *      x-naanide-ep:       <target-url-with-path-and-query-variables>
+ *      x-naanide-hdrs:     <optional headers>
+ *
+ * The response in the browser contains some remapped headers, but is otherwise the API's response.
+ *
+ * Assuming the pre-shared key is "foo", the following gets a list of YDB databases in a folder:
+
+curl -H "x-naanide-auth: foo" \
+     -H "x-naanide-ep: https://ydb.api.cloud.yandex.net/ydb/v1/databases?folderId=b1gjjahqm5u9tjolom9l" \
+     'https://functions.yandexcloud.net/d4e5gicpajcqdbj91jt8'
+
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2022 by Richard C. Zulch
+ * 
+ */
+
+
+/*
+ * index.handler
+ *
+ * Forward a request and respond with the result.
+ *
+ */
+
+module.exports.handler = async function (event, context) {
+    "use strict";
+    const authorizationKey = process.env.NAANIDE_AUTH_KEY;
+    
+    //
+    // OPTIONS request
+    //
+    // Allow our headers for CORS
+    //
+
+    if (event.httpMethod == "OPTIONS")
+        return {
+            statusCode: 200,
+            headers: {
+                "Access-Control-Allow-Headers": "*"
+            }
+        };
+    
+    //
+    // Failed authentication
+    //
+
+    if (event.headers["X-Naanide-Auth"] != authorizationKey) {
+        return {
+            statusCode: 401
+        };
+    }
+    
+    //
+    // Authenticated
+    //
+
+    let https = require("https");
+    let url = event.headers["X-Naanide-Ep"];
+    let headers = event.headers["X-Naanide-Hdrs"];
+    if (headers) {
+        try {
+            headers = JSON.parse(headers);
+        } catch (e) {
+            console.log("X-Naanide-Hdrs parse error", e);
+            headers = false;
+        }
+    }
+    if (!headers)
+        headers = { };
+    if (!headers[Object.keys(headers).find(key => key.toLowerCase() === "authorization")])
+        headers.Authorization = context.token.token_type.concat(" ", context.token.access_token);
+    let options = {
+        method: event.httpMethod,
+        headers: headers
+    };
+    let chunks = [];
+    let content = false;
+    let finalResponse = {
+        statusCode: 500
+    };
+
+    //
+    // forward_request
+    //
+    async function forward_request() {
+        return new Promise(function(resolve, reject) {
+            let req = https.request(url, options, function(resp) {
+                finalResponse.statusCode = resp.statusCode;
+                // data event
+                resp.on("data", function (chunk) {
+                    chunks.push(chunk);
+                });
+                // end event
+                resp.on("end", function () {
+                    if (resp.complete)
+                    {
+                        let content = Buffer.concat(chunks);
+                        let contentType = resp.headers["content-type"];
+                        finalResponse.body = content.toString();
+                        if (resp.headers["x-request-id"]) {
+                            resp.headers["x-upstream-request-id"] = resp.headers["x-request-id"];
+                            delete resp.headers["x-request-id"];
+                        }
+                        finalResponse.headers = resp.headers;
+                    }
+                    else {
+                        console.log("request terminated before full response received");
+                        finalResponse.statusCode = 502;
+                    }
+                    resolve();
+                });
+            });
+            // error event
+            req.on("error", function (err) {
+                console.log("upstream request error:", err);
+                finalResponse.statusCode = 502;
+                reject(err);
+            });
+            console.log("event.body", event.body, event.isBase64Encoded);
+            if (event.body) {
+                if (event.isBase64Encoded)
+                    req.write(decodeURIComponent(escape(atob(event.body))));
+                else
+                    req.write(event.body);
+            }
+            req.end();
+        });
+    }
+    
+    await forward_request();
+    return finalResponse;
+}

package/plugins/serviceYC/serviceYC.nlg

@@ -0,0 +1,59 @@
+/*
+ * serviceYC.nlg
+ * serviceYC
+ *
+ *     ServiceYC module configuration and management for browser and NodeJS.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2022 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * YcRequest
+ *
+ *     Make a request to a Yandex Cloud API using a Yandex Cloud Function acting as a relay proxy.
+ * This works like frameworks/browser/HttpsApiRequest and frameworks/node/HttpsApiRequest except
+ * that it takes a credentials argument for access to the relay. Technically this is not required
+ * when we are going from node, but I'm keeping it for consistency.
+ *
+ */
+
+closure YcRequest(url, creds, options, local headers) {
+    if !options
+        options = { }
+    else
+        options = new(options)
+    headers = [
+        list("x-naanide-auth", creds.relayAuthKey)
+        list("x-naanide-ep", url)
+    ]
+    if options.headers
+        headers.push(list("x-naanide-hdrs", options.headers.join("\n")))
+    options.headers = headers
+    https.HttpsApiRequest(creds.relayURL, options)
+};
+
+
+/*
+ * seycInit
+ *
+ *     Initialize the YC module.
+ *
+ */
+
+function seycInit(local manifest) {
+    manifest = `(YcRequest, seycInit)
+
+    Naan.module.build(module.id, "serviceYC", function(modobj, compobj) {
+        compobj.manifest = manifest
+        require("frameworks/common").LiveImport()
+        if js.g
+            https = require("frameworks/node/https_request.nlg")
+        else
+            https = require("frameworks/browser/https_request.nlg")
+        module.exports.YcRequest = YcRequest
+    })
+} ();

package/plugins/serviceYC/yc_function.nlg

@@ -0,0 +1,161 @@
+/*
+ * yc_function.nlg
+ * serviceYC
+ *
+ *     Access to serverless function management services for YC.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2022 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * YCFunction
+ *
+ *     YCFunction manipulation functions.
+ *
+ */
+
+closure YCFunction(local ycfun) {
+    ycfun = new(object, this)
+
+    //
+    // login
+    //
+    ycfun.login = closure login(creds) {
+        ycfun.creds = creds
+        list(false, { ok: true })
+    }
+    
+    //
+    // getFunction
+    //
+    // Get basic function info like:
+    //  {
+    //      id           : "d4er5sq67r5j47nno6nb",
+    //      folderId     : "b1gjjahqm5u9tjolom9l",
+    //      createdAt    : "2022-08-30T00:57:18.024Z",
+    //      name         : "hello-world",
+    //      description  : "A quick first function.",
+    //      logGroupId   : "ckgbmh6df6dt92pphc6b",
+    //      httpInvokeUrl: "https://functions.yandexcloud.net/d4er5sq67r5j47nno6nb",
+    //      status       : "ACTIVE"
+    //  }
+    //
+    ycfun.getFunction = closure getFunction(funcID, local url, error, data) {
+        debuglog("YCFunction.getFunction", funcID)
+        url = "https://serverless-functions.api.cloud.yandex.net/functions/v1/functions/".concat(funcID)
+        `(error, data) = YcRequest(url, ycfun.creds, {
+            query: { x: 1 }
+        })
+        if error
+            debuglog("YCFunction.getFunction failed:", ErrorString(error))
+        list(error, data)
+    }
+
+    //
+    // getVersionByTag
+    //
+    // Get info about a specific function version using its tag, e.g. $latest:
+    //  {
+    //      resources       : { memory: "134217728" },
+    //      tags            : ["$latest"],
+    //      id              : "d4evm4lsi91hqkv78ane",
+    //      functionId      : "d4er5sq67r5j47nno6nb",
+    //      createdAt       : "2022-08-31T03:32:59.577Z",
+    //      runtime         : "nodejs16",
+    //      entrypoint      : "index.handler",
+    //      executionTimeout: "3s",
+    //      serviceAccountId: "aje9s3df60gofsddio0c",
+    //      imageSize       : "4096",
+    //      status          : "ACTIVE",
+    //      logGroupId      : "ckgbmh6df6dt92pphc6b" }
+    //  }
+    //
+    ycfun.getVersionByTag = closure getVersionByTag(funcID, tag, local url, error, data) {
+        url = "https://serverless-functions.api.cloud.yandex.net/functions/v1/versions:byTag".concat(
+            EncodeQuery("?", {
+                functionId: funcID
+                tag: tag
+            }))
+        `(error, data) = YcRequest(url, ycfun.creds, {
+            query: { x: 1 }
+        })
+        if error
+            debuglog("YCFunction.getVersionByTag failed:", ErrorString(error))
+        list(error, data)
+    }
+
+    //
+    // invokeFunction
+    //
+    // Invoke a public cloud function. It is impossible to invoke a private cloud function from 
+    // browsers because the function cannot respond to a CORS authorization request using the OPTIONS
+    // method without an authorization header that cannot be added to the preflight.
+    //
+    ycfun.invokeFunction = closure invokeFunction(funcID, local url, error, data) {
+        url = "https://functions.yandexcloud.net/".concat(funcID)
+        `(error, data) = https.HttpsApiRequest(url, {
+            query: { x: 1 }
+        })
+        if error
+            debuglog("YCFunction.invokeFunction failed:", ErrorString(error))
+        list(error, data)
+    }
+
+    //
+    // updateFunctionCode
+    //
+    //
+    ycfun.updateFunctionCode = closure updateFunctionCode(info, bucket, key, sha256,
+        local url, params, error, data) {
+        params = {
+            function_id:        info.functionId
+            functionID:         info.functionId
+            runtime:            info.runtime
+            description:        "Updated: ".concat(Date())
+            entrypoint:         info.entrypoint
+            resources:          info.resources
+            executionTimeout:   info.executionTimeout
+            serviceAccountId:   info.serviceAccountId
+            package: {
+                bucketName:     bucket
+                objectName:     key
+                sha256:         sha256
+            }
+        }
+        if info.environment
+            params.environment = info.environment
+        url = "https://serverless-functions.api.cloud.yandex.net/functions/v1/versions"
+        `(error, data) = YcRequest(url, ycfun.creds, {
+            putdata: params
+        })
+        if error
+            debuglog("YCFunction.updateFunctionCode failed:", ErrorString(error))
+        list(error, data)
+    }
+
+    // finis
+    ycfun
+}
+
+
+/*
+ * ycFunctionInit
+ *
+ *     Initialize the module.
+ *
+ */
+
+function ycFunctionInit(local manifest) {
+    manifest = `(YCFunction, ycFunctionInit)
+
+    Naan.module.build(module.id, "yc_function", function(modobj, compobj) {
+        require("./serviceYC.nlg")
+        compobj.manifest = manifest
+        modobj.exports.YCFunction = YCFunction
+    })
+
+} ();

package/test/test_01_core.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2022 by Richard C. Zulch
+ * Copyright (c) 2017-2023 by Richard C. Zulch
  *
  */
 
@@ -417,7 +417,7 @@ RegisterTestCategory("core", [
         "2 3 4 caught: done|cleanup|\"xo\"" ],
     [ "try { looper() } catch { if false { print(\"caught: \"), printline(exception), \"xo\" } } finally { printline(cleanup) };",
         { errors: "exception: done", text: "2 3 4 cleanup" } ],
-    [ "try { looper() } catch { if false { print(\"caught: \"), printline(exception), \"xo\" } } finally { throw(3), printline(cleanup) };",
+    [ "try { looper() } catch { if false { print(\"caught: \"), printline(exception), \"xo\" } } finally { throw(3) };",
         { errors: "exception: 3", text: "2 3 4" } ],
     [ "try { throw(blah) } catch { if true try { throw(needer) } catch { if true exception } };",
         "needer" ],

package/test/test_02_context.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2022 by Richard C. Zulch
+ * Copyright (c) 2017-2023 by Richard C. Zulch
  *
  */
 
@@ -38,7 +38,7 @@ RegisterTestCategory("context", [
     [ "function setNS(ns) { ns=reverse(ns),sudo(nsactive(reverse(ns, defNS))) };", "setNS" ],
     [ "x;", "x" ],
     [ "y;", "y" ],
-    [ "length(symlist(nsactive(true).0));", "170"],
+    [ "length(symlist(nsactive(true).0));", "173"],
     [ "testvar;", "testvar" ],
     [ "function setTestvar(v) { testvar=v };", "setTestvar" ],
     [ "naanvar;", "naanvar" ],

package/test/test_05_strings.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2021 by Richard C. Zulch
+ * Copyright (c) 2017-2023 by Richard C. Zulch
  *
  */
 
@@ -47,6 +47,16 @@ RegisterTestCategory("strings", [
     [ "c=compress(\"b\", 123);", "b123" ],
 
 
+    //
+    // template strings
+    //
+
+    [ "'$${4+3}';", '"7"' ],                                                // these have an extra $escape
+    [ "'$$${4+3}';", '"$${4+3}"' ],
+    [ "'a$${4+3}b';", '"a7b"' ],
+    [ "'$${}';", '' ],
+
+
     //
     // string native functions
     //

package/test/test_06_lingoparse.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2018-2021 by Richard C. Zulch
+ * Copyright (c) 2018-2023 by Richard C. Zulch
  *
  */
 
@@ -63,7 +63,7 @@ RegisterTestCategory("Lingo parse", [
     [ "4&&3;", { exprs: "(&& 4 3)" } ],
     [ "4\n&&3;", { exprs: "(&& 4 3)" } ],
     [ "4&&\n3;", { exprs: "(&& 4 3)" } ],
-    [ "function test0(x, y) { \n x \n y = 3 \n };", { exprs: "(defproc function test0 (x y) x (= y 3))" } ],
+    [ "function test0(x, y) { \n y = 3\n x  \n };", { exprs: "(defproc function test0 (x y) (= y 3) x)" } ],
 
     //
     // Procedure types
@@ -297,8 +297,8 @@ RegisterTestCategory("Lingo parse", [
         { exprs: "(defproc function test2 (x) (loop false ((> x 3) (print \"done\")) (printline \"loop \" x) (= x (+ x 1))))",
         text: "==> redefined: test2" } ],
     
-    [ "function test2(x) { loop { if x > 3 print(\"done\"), break, printline(\"loop \", x), x = x+1 } };",
-        { exprs: "(defproc function test2 (x) (loop false (((> x 3) (print \"done\"))) (break) (printline \"loop \" x) (= x (+ x 1))))",
+    [ "function test2(x) { loop { if x > 3 print(\"done\"), break } };",
+        { exprs: "(defproc function test2 (x) (loop false (((> x 3) (print \"done\"))) (break)))",
         text: "==> redefined: test2" } ],
     
     [ "function test2(x) { loop { if x > 3 if x > 2 { print(\"done\"), break }, printline(\"loop \", x), x = x+1 } };",
@@ -313,8 +313,8 @@ RegisterTestCategory("Lingo parse", [
         { exprs: "(defproc function test2 (x) (loop false (((> x 3) (((> x 2) (print \"done\"))) (break))) (printline \"loop \" x) (= x (+ x 1))))",
         text: "==> redefined: test2" } ],
     
-    [ "function test2(x) { loop { if x <= 3 print(\" \") else break, printline(\"loop \", x), x = x+1 } };",
-        { exprs: "(defproc function test2 (x) (loop false (((<= x 3) (print \" \")) (break)) (printline \"loop \" x) (= x (+ x 1))))",
+    [ "function test2(x) { loop { if x <= 3 print(\" \") else break } };",
+        { exprs: "(defproc function test2 (x) (loop false (((<= x 3) (print \" \")) (break))))",
         text: "==> redefined: test2" } ],
     
     [ "function test2(x) { loop { if x > 3 { if x > 2 { print(\"done\"), break }, print(\" \")} , printline(\"loop \", x), x = x+1 } };",
@@ -346,12 +346,12 @@ RegisterTestCategory("Lingo parse", [
     [ "function(x) { loop { if x 2 else if y 3 } };",
         { exprs: "(function lambda (x) (loop false (((identity x) 2) ((identity y) 3))))" } ],
 
-    [ "function() { if 1 { 2, loop { if 3 4 }, 5 } };",
-        { exprs: "(function lambda false ((identity 1) 2 (loop false (((identity 3) 4))) 5))" } ],
-    [ "function() { if 1 { 2, loop { if 3 4 }, 5 } };",
+    [ "function() { if 1 { f(2), loop { if 3 4 }, 5 } };",
+        { exprs: "(function lambda false ((identity 1) (f 2) (loop false (((identity 3) 4))) 5))" } ],
+    [ "function() { if 1 { f(2), loop { if 3 4 }, 5 } };",
         "function () {\n"
         "    if 1 {\n"
-        "        2\n"
+        "        (f, 2)\n"
         "        loop\n"
         "            if 3\n"
         "                4\n"
@@ -421,11 +421,11 @@ RegisterTestCategory("Lingo parse", [
         
     [ "return;", { exprs: "(return)" } ],
     [ "return (777);", { exprs: "(return 777)" } ],
-    [ "function test4() { loop :dumb { if 1 < 2 { 3, break :dumb }, 4 }};",
-        { exprs: "(defproc function test4 false (loop dumb (((< 1 2) 3 (break dumb))) 4))",
+    [ "function test4() { loop :dumb { if 1 < 2 { f(3), break :dumb }, 4 }};",
+        { exprs: "(defproc function test4 false (loop dumb (((< 1 2) (f 3) (break dumb))) 4))",
         text: "==> redefined: test4" } ],
-    [ "function test4() { loop :smart { if 1 < 2 { 3, continue :smart }, 4 }};",
-        { exprs: "(defproc function test4 false (loop smart (((< 1 2) 3 (continue smart))) 4))",
+    [ "function test4() { loop :smart { if 1 < 2 { f(3), continue :smart }, 4 }};",
+        { exprs: "(defproc function test4 false (loop smart (((< 1 2) (f 3) (continue smart))) 4))",
         text: "==> redefined: test4" } ],
 
     //
@@ -497,4 +497,33 @@ RegisterTestCategory("Lingo parse", [
         "    else {\n"
         "        { a: 3 } }\n"                                              // need braces around dictionary
         "}" ],
+
+    //
+    // semantic validity
+    //
+
+    [ "function(x) { 3, x };",
+        { errors: "ignored atom in body at (1, 15) found 3" } ],
+    [ "function(x x) { x * x };",
+        { errors: "duplicate parameter at (1, 12) found x" } ],
+    [ "function(3) { 33 };",
+        { errors: "invalid parameter at (1, 11) found 3" } ],
+    [ "global(test);",
+        { errors: "global forbidden outside of a procedure at (1, 1)" } ],
+    [ "function(a) { b * a };",
+        { text: "" } ],
+    [ "function(a) { global(b), b * a };",
+        { text: "" } ],
+    [ "function&(a) { global(b), b * a };",
+        { errors: "global forbidden in function& and let& at (1, 16)" } ],
+    [ "let&(a) { global(b), b * a };",
+        { errors: "global forbidden in function& and let& at (1, 11)" } ],
+    [ "function(a) { global(b), a.c };",
+        { text: "" } ],
+    [ "function(a) { global(b), c.a };",
+        { errors: "undeclared global at (1, 26) found c" } ],
+    [ "function(a) { global(b), c * a };",
+        { errors: "undeclared global at (1, 26) found c" } ],
 ]);
+
+