@naanlang/naan 1.0.7 → 1.0.8

package/plugins/serviceAws/aws/lambda_ws_init.nlg

@@ -22,7 +22,8 @@ function initPreload() {
     Naan.module.chns("Play")
     sudo(putproc(exception, false))                                         // ### need a better mechanism
 };
-initPreload();
+if symbol(NideBuild)
+    initPreload();                                                          // not building
 
 
 /*

package/plugins/serviceAws/aws_dynamo.nlg

@@ -652,7 +652,7 @@ closure DynaTable(dyna, tablename, local table) {
     // Ensure that the table is ready before executing an operation. This returns an error tuple or
     // false to proceed.
     //
-    function preflightError(op) {
+    function preflightError(op, local result) {
         if !dyna.aws
             return (list(Error("DynaTable.".concat(op, ": not logged into AWS"))))
         if !table.hashKey {
@@ -683,7 +683,7 @@ closure DynaTable(dyna, tablename, local table) {
     //
     // Get a record from the table with the specified hash value, and optional range value.
     //
-    table.getRecord = closure getRecord(hashValue, rangeValue, local result, params, pending) {
+    table.getRecord = closure getRecord(hashValue, rangeValue, local params, pending) {
         if preflightError(this)
             return
         params = {
@@ -708,7 +708,7 @@ closure DynaTable(dyna, tablename, local table) {
     //
     //     Put a record in the table, replacing any existing record with the same key.
         
-    table.putRecord = closure putRecord(record, local result, params, pending) {
+    table.putRecord = closure putRecord(record, local params, pending) {
         if preflightError(this)
             return
         params = {
@@ -737,13 +737,15 @@ closure DynaTable(dyna, tablename, local table) {
     //      set:        [`(attribute, value)]   // set attributes to values
     //      sum:        [`(attribute, value)]   // attributes += values
     //      diff:       [`(attribute, value)]   // attributes -= values
+    //      add:        [`(attribute, value)]   // ADD(attributes, values) -- attrib need not exist
     //      remove:     [attribute]             // remove attributes from the record
     //      return:     "all_old" | "all_new" | "updated_old" | "updated_new"
     //                                          // return the record as chosen, otherwise { }
     //  }
     // The result is a standard result tuple `(error, record).
         
-    table.updateRecord = closure updateRecord(hashValue, rangeValue, options, local error, result, params, actions, pending) {
+    table.updateRecord = closure updateRecord(hashValue, rangeValue, options,
+        local error, params, actions, pending) {
         if preflightError(this)
             return
         params = {
@@ -752,13 +754,10 @@ closure DynaTable(dyna, tablename, local table) {
         params.Key = makeDynKey(list(hashValue, rangeValue))
         if options.condition {
             `(error) = dyna.conv.createKeyExpression(params, {
-                KeyConditionExpression: {
-                    key: table.hashKey
-                    "=": hashValue
-                }
+                ConditionExpression: options.condition
             })
             if error
-                return (list(Error("table.updateRecord:", error)))
+                return (list(Error("table.updateRecord condition:", error)))
         }
         dyna.conv.createUpdateExpression(params, options)
         if options.return {
@@ -795,7 +794,8 @@ closure DynaTable(dyna, tablename, local table) {
     //  }
  
         
-    table.deleteRecord = closure deleteRecord(hashValue, rangeValue, options, local result, params, pending) {
+    table.deleteRecord = closure deleteRecord(hashValue, rangeValue, options,
+        local params, pending) {
         if preflightError(this)
             return
         params = {
@@ -804,13 +804,10 @@ closure DynaTable(dyna, tablename, local table) {
         params.Key = makeDynKey(list(hashValue, rangeValue))
         if options.condition {
             `(error) = dyna.conv.createKeyExpression(params, {
-                KeyConditionExpression: {
-                    key: table.hashKey
-                    "=": hashValue
-                }
+                ConditionExpression: options.condition
             })
             if error
-                return (list(Error("table.deleteRecord:", error)))
+                return (list(Error("table.deleteRecord condition:", error)))
         }
         if options.return {
             params.ReturnValues = {
@@ -871,7 +868,7 @@ closure DynaTable(dyna, tablename, local table) {
     //
 
     table.queryRecords = closure queryRecords(hashValue, options
-        local error, result, params, hashKey, op, expr, output, error)
+        local error, params, hashKey, op, expr, output, error)
     {
         if preflightError(this)
             return
@@ -940,7 +937,7 @@ closure DynaTable(dyna, tablename, local table) {
     //
 
     table.scanRecords = closure scanRecords(options
-        local result, params, op, expr, output, error)
+        local params, op, expr, output, error)
     {
         if preflightError(this)
             return
@@ -1044,9 +1041,9 @@ closure DynamoDB(local dyna) {
         dynexBatchGetRecords(dyna, request, options)
     }
     
-    // dynexBatchWriteRecords
+    // batchWriteRecords
     //
-    dyna.batchWriteRecords = function batchWriteRecords(request, options) {
+    dyna.batchWriteRecords = function loadBatchWriteRecords(request, options) {
         require("./aws_dynextra.nlg")
         dyna.batchWriteRecords = function bwr(request, options) {
             dynexBatchWriteRecords(dyna, request, options)
@@ -1054,7 +1051,7 @@ closure DynamoDB(local dyna) {
         dynexBatchWriteRecords(dyna, request, options)
     }
     
-    // dynexTransactGetRecords
+    // transactGetRecords
     //
     dyna.transactGetRecords = function loadTransactGetRecords(request, options) {
         require("./aws_dynextra.nlg")
@@ -1064,6 +1061,16 @@ closure DynamoDB(local dyna) {
         dynexTransactGetRecords(dyna, request, options)
     }
 
+    // transactWriteRecords
+    //
+    dyna.transactWriteRecords = function loadTransactWriteRecords(request, options) {
+        require("./aws_dynextra.nlg")
+        dyna.transactWriteRecords = function tgr(request, options) {
+            dynexTransactWriteRecords(dyna, request, options)
+        }
+        dynexTransactWriteRecords(dyna, request, options)
+    }
+
     // finis
     dyna
 }

package/plugins/serviceAws/aws_dynextra.nlg

@@ -228,7 +228,6 @@ closure dynexBatchWriteRecords(dyna, request,
 };
 
 
-
 /*
  * dynexTransactGetRecords
  *
@@ -257,10 +256,10 @@ closure dynexTransactGetRecords(dyna, request,
     for titem in request {                                                  // preflight all tables
         tname = titem.table.name
         if index[tname]
-            return (Error("DynaTable.batchGetRecords: duplicate table in request:", tname))
+            return (Error("DynaTable.transactGetRecords: duplicate table in request:", tname))
         `(error) = titem.table.info()
         if error
-            return (Error("DynaTable.batchGetRecords: table", tname, ":", error))
+            return (Error("DynaTable.transactGetRecords: table", tname, ":", error))
         titem.data = []
         index[tname] = titem
     }
@@ -272,7 +271,7 @@ closure dynexTransactGetRecords(dyna, request,
             params.TransactItems.push({
                 Get: {
                     TableName: tname
-                    Key: makeDynKey(titem.keys.shift())
+                    Key: titem.table.makeDynKey(titem.keys.shift())
                 }
             })
         }
@@ -297,6 +296,111 @@ closure dynexTransactGetRecords(dyna, request,
 };
 
 
+/*
+ * dynexTransactWriteRecords
+ *
+ * column positioning:                          //                          //                      !
+ * Write records to one or more tables using arrays of keys as a single transaction. The result is an
+ * error if anything failed or generic success if it worked. The request layout is as follows. Note
+ * that unlike the other dynex* calls, each table/key/operation item is separately specified.
+ *
+ *  [
+ *      {
+ *          table:  <DynaTable object>          // table to act upon
+ *          key:    <hash-range tuple>
+ *          put:    {
+ *              condition:  <range-expression>  // conditional expression
+ *              item:       <record-to-put>
+ *          }
+ *          update: {
+ *              condition:  <range-expression>      // conditional expression
+ *              set:        [`(attribute, value)]   // set attributes to values
+ *              sum:        [`(attribute, value)]   // attributes += values
+ *              diff:       [`(attribute, value)]   // attributes -= values
+ *              add:        [`(attribute, value)]   // ADD(attributes, values) -- attrib need not exist
+ *              remove:     [attribute]             // remove attributes from the record
+ *          }
+ *          delete: {
+ *              condition:  <range-expression>  // conditional expression
+ *          }
+ *          check:  {
+ *              condition:  <range-expression>  // conditional expression
+ *              return:     "all_old"           // optionally return record if condition fails
+ *          }
+ *      }
+ *      { <next-item> }
+ *  ]
+ * This returns a standard result tuple `(error, result). An error is only reported if we are 
+ * unable to complete all operations.
+ *
+ */
+
+closure dynexTransactWriteRecords(dyna, request,
+    local index, titem, tname, error, params, opset, spec, op, pending, response) {
+    if !dyna.aws
+        return (list(Error("DynaTable.transactWriteRecords: not logged into AWS")))
+    request = new(request)                                                  // allow local modifications
+    index = { }
+    for titem in request {                                                  // preflight all tables
+        tname = titem.table.name
+        if !index[tname] {
+            `(error) = titem.table.info()
+            if error
+                return (Error("DynaTable.transactWriteRecords: table", tname, ":", error))
+            index[tname] = titem
+        }
+    }
+    params = {
+        TransactItems: []
+    }
+    for titem in request {
+        opset = {
+            TableName: titem.table.name
+            Key: titem.table.makeDynKey(titem.key)
+        }
+        if titem.check {
+            spec = titem.check
+            op = `ConditionCheck
+            if spec.return
+                opset.ReturnValues = "ALL_OLD"
+        } else if titem.put {
+            spec = titem.put
+            op = `Put
+            opset.Item = dyna.conv.recordNaanToDyn(spec.item)
+            opset.Key = undefined                                           // key must be in item
+        } else if titem.update {
+            spec = titem.update
+            op = `Update
+            dyna.conv.createUpdateExpression(opset, spec)
+        } else if titem.delete {
+            spec = titem.delete
+            op = `Delete
+        }
+        if spec.condition {
+            `(error) = dyna.conv.createKeyExpression(opset, {
+                ConditionExpression: spec.condition
+            })
+            if error
+                return (list(Error("DynaTable.transactWriteRecords condition:", error)))
+        }
+        titem = { }
+        titem[op] = opset
+        params.TransactItems.push(titem)
+    }
+    pending = new(nonce)
+    dyna.aws.transactWriteItems(params, function(err, data) {
+        if err
+            debuglog("aws.transactWriteItems failed", err)
+        pending.signal(list(err, data))
+    })
+    `(error, response) = pending.wait()
+    if error
+        list(error)
+    else
+        list(false, response)
+};
+
+
 /*
  * dynexInit
  *
@@ -305,7 +409,8 @@ closure dynexTransactGetRecords(dyna, request,
  */
 
 function dynexInit(local manifest) {
-    manifest = `(dynexBatchGetRecords, dynexBatchWriteRecords, dynexTransactGetRecords, dynexInit)
+    manifest = `(dynexBatchGetRecords, dynexBatchWriteRecords, dynexTransactGetRecords,
+        dynexTransactWriteRecords, dynexInit)
 
     Naan.module.build(module.id, "aws_dynextra", function(modobj, compobj) {
         compobj.manifest = manifest

package/plugins/serviceAws/aws_lambda.nlg

@@ -46,10 +46,8 @@ closure Lambda(local lamb) {
             params.Qualifier = qualifier
         pending = new(nonce)
         lamb.aws.getFunction(params, function(error, data) {
-            if error {
-                lambdaError = error
-                debuglog("aws.getFunction failed", error)
-            }
+            if error
+                ErrorDebuglog("aws.getFunction failed", error)
             pending.signal(list(error, data))
         })
         pending.wait()
@@ -69,10 +67,8 @@ closure Lambda(local lamb) {
         }
         pending = new(nonce)
         lamb.aws.updateFunctionCode(params, function(error, data) {
-            if error {
-                lambdaError = error
-                debuglog("aws.updateFunctionCode failed", error)
-            }
+            if error
+                ErrorDebuglog("aws.updateFunctionCode failed", error)
             pending.signal(list(error, data))
         })
         pending.wait()

package/plugins/serviceAws/aws_sqs.nlg

@@ -0,0 +1,113 @@
+/*
+ * aws_sqs.nlg
+ * serviceAws
+ *
+ *     Access to SQS (Simple Queue Service) for AWS.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2023 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * SqsMQ
+ *
+ *     SqsMQ, a container for holding the queue name and sending messages to it.
+ *
+ */
+
+closure SqsMQ(sqs, queueUrl, local sqsq) {
+    sqsq = new(object, this)
+
+    //
+    // sendMessage
+    //
+    sqsq.sendMessage = closure sendMessage(msgBody) {
+        sqs.sendMessage(queueUrl, msgBody)
+    }
+    
+    // finis
+    sqsq
+}
+
+
+/*
+ * SQS
+ *
+ *     SQS service functions.
+ *
+ */
+
+closure SQS(local sqs) {
+    sqs = new(object, this)
+
+    //
+    // login
+    //
+    sqs.login = closure login(creds, local params) {
+        if !awsSDK
+            return (list(Error("SQS.login: no AWS SDK available")))
+        params = {
+        }
+        if creds {
+            params.region = creds.region
+            params.credentials = {
+                accessKeyId:        creds.keyID
+                secretAccessKey:    creds.keySecret
+            }
+            if creds.sqs_endpoint
+                params.endpoint = creds.sqs_endpoint
+        }
+        sqs.aws = xnew(awsSDK.SQS, params)
+        `(false, { ok: true })
+    }
+    
+    //
+    // sendMessage
+    //
+    sqs.sendMessage = closure sendMessage(queueUrl, msgBody, local params, pending) {
+        debuglog("SQS.sendMessage:", awsSDK, sqs.aws, sqs.aws.sendMessage)
+        params = {
+            MessageBody: msgBody
+            QueueUrl: queueUrl
+        }
+        pending = new(nonce)
+        sqs.aws.sendMessage(params, function(error, data) {
+            if error
+                ErrorDebuglog("aws.sendMessage failed", error)
+            pending.signal(list(error, data))
+        })
+        pending.wait()
+    }
+    
+    //
+    // mq
+    //
+    sqs.mq = function(queueUrl) {
+        SqsMQ(sqs, queueUrl)
+    }
+
+    // finis
+    sqs
+}
+
+
+/*
+ * sqsInit
+ *
+ *     Initialize the SQS module.
+ *
+ */
+
+function sqsInit(local manifest) {
+    manifest = `(SqsMQ, SQS, sqsInit)
+
+    Naan.module.build(module.id, "aws_sqs", function(modobj, compobj) {
+        require("./serviceAws.nlg")
+        compobj.manifest = manifest
+        modobj.exports.SQS = SQS
+    })
+
+} ();

package/plugins/serviceAws/serviceAws.nlg

@@ -27,7 +27,7 @@ function sawsInit(local manifest) {
         require("./aws_utils.nlg")
         function sawsPostload() {
             if js.g
-                awsSDK = js.r(JSpath.join(js.d, module.locpath, "./aws/aws-sdk-node.min.js"))
+                awsSDK = js.r(JSpath.resolve(js.d, module.locpath, "aws/aws-sdk-node.min.js"))
             else
                 awsSDK = JsLoadScript(JSpath.join(module.locpath, "./aws/aws-sdk.min.js"), "awsSdk")
             module.exports.awsSDK = awsSDK

package/plugins/serviceYC/generic_api.yaml

@@ -0,0 +1,36 @@
+openapi: 3.0.0
+info:
+  title: tutor-backend API
+  version: 1.0.0
+servers:
+- url: https://d5dhrgakpe39e11lqefr.apigw.yandexcloud.net
+paths:
+  /{proxy+}:
+    options:
+      parameters:
+      - name: proxy
+        in: path
+        required: true
+        schema:
+          type: string
+      x-yc-apigateway-integration:
+        type: dummy
+        http_code: 200
+        http_headers:
+          Access-Control-Allow-Headers: "*"
+          Access-Control-Allow-Methods: "DELETE,GET,HEAD,OPTIONS,PATCH,POST,PUT"
+          Access-Control-Allow-Origin: "*"
+        content:
+          "application/json": ""
+    x-yc-apigateway-any-method:
+      parameters:
+      - name: proxy
+        in: path
+        required: true
+        schema:
+          type: string
+      x-yc-apigateway-integration:
+        type: cloud_functions
+        function_id: d4ehjjcfk8ffe43o5t7j
+        tag: $latest
+        service_account_id: ajeuftvbtshn348ert80

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
+    })
+} ();