@naanlang/naan 1.0.7 → 1.0.9

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

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2021-2022 by Richard C. Zulch
+ * Copyright (c) 2021-2023 by Richard C. Zulch
  *
  */
 
@@ -88,7 +88,7 @@ closure TimeKeys(prefix, baseMS, local timekeys, prelen) {
     // partition key in the specified direction, or false if there are no more keys. Dates in the
     // future are considered invalid and return false.
     //
-    timekeys.adjustPartID = function adjustPartID(partID, adjust, local year, doy, dayms, msec) {
+    timekeys.adjustPartID = function adjustPartID(partID, adjust, local yyyy, doy, dayms, msec) {
         partID = partID.slice(prelen)
         yyyy = toint(partID.substring(0,4))
         doy = toint(partID.substring(4,7))
@@ -246,7 +246,7 @@ closure DynaConverter(local conv) {
     // datumDynToNaan
     // Convert a DynamoDB typed attribute to Naan format.
     //
-    conv.datumDynToNaan = function datumDynToNaan(dtype, dvalue, local output) {
+    conv.datumDynToNaan = function datumDynToNaan(dtype, dvalue) {
         if dtype == "BS" || dtype == "SS"
             dvalue
         else if dtype == "NS"
@@ -305,7 +305,7 @@ closure DynaConverter(local conv) {
     // specified parameter block.
     //
     closure genAttributeNameAdder(params, local adex) {
-        function attrib(name, local adef, atype, key, data) {
+        function attrib(name, local key, data) {
             if !string(name)
                 name = tostring(name)                                       // try to make it a string
             if !params.ExpressionAttributeNames
@@ -377,7 +377,7 @@ closure DynaConverter(local conv) {
     //
 
     conv.createKeyExpression = function createKeyExpression(params, conds
-        local error, attval, rangename, range, keyname, op, expr, rangex, arg1, arg2) {
+        local attval, rangename, range, keyname, op, expr, rangex, arg1, arg2) {
 
         // dupeop
         //
@@ -535,7 +535,7 @@ closure DynaTable(dyna, tablename, local table) {
     //      rangeType:  <name>                  // string | numeric (if exists)
     //  }
     //
-    table.info = closure info(local params, pending, info) {
+    table.info = closure info(local params, pending) {
         if !dyna.aws
             return (list(Error("DynaTable.info: not logged into AWS")))
         params = {
@@ -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 = {
@@ -691,7 +691,7 @@ closure DynaTable(dyna, tablename, local table) {
         }
         params.Key = makeDynKey(list(hashValue, rangeValue))
         pending = new(nonce)
-        dyna.aws.getItem(params, function(error, data, local output) {
+        dyna.aws.getItem(params, function(error, data) {
             if error {
                 dynaTableError = error
                 debuglog("aws.getItem failed", tablename, ErrorString(error))
@@ -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 = {
@@ -716,7 +716,7 @@ closure DynaTable(dyna, tablename, local table) {
             Item: dyna.conv.recordNaanToDyn(record)
         }
         pending = new(nonce)
-        dyna.aws.putItem(params, function(error, data, local output) {
+        dyna.aws.putItem(params, function(error, data) {
             if error {
                 dynaTableError = error
                 debuglog("aws.putItem failed", tablename, ErrorString(error))
@@ -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, 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 = {
@@ -820,7 +817,7 @@ closure DynaTable(dyna, tablename, local table) {
                 params.ReturnValues = "NONE"
         }
         pending = new(nonce)
-        dyna.aws.deleteItem(params, function(error, data, local output) {
+        dyna.aws.deleteItem(params, function(error, data) {
             if error {
                 dynaTableError = error
                 debuglog("aws.deleteItem failed", tablename, ErrorString(error))
@@ -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, output)
     {
         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, 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/dbt_aws.nlg

@@ -365,7 +365,7 @@ closure dawsTable(database, path, tableOptions, local table) {
     //
     // Convert an S3 get response to a new table document.
     
-    function s3resp2doc(resp, local doc, metadata, metakey) {
+    function s3resp2doc(resp, local doc) {
         if resp.Metadata.naandbt
             try {
                 doc = new(JSONparse(resp.Metadata.naandbt))
@@ -787,7 +787,7 @@ closure S3DB(s3b, local database, result) {
     //
     // Delete the database and close it.
 
-    database.destroy = function destroy(local pending) {
+    database.destroy = function destroy() {
         if !database.bucket
             return (list(Error("database closed")))
         list(Error("not sure how to destroy this database"))                // ### delete the base object?

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