@voxgig/build 3.1.0 → 4.1.0

package/env/lambda/srv_handler.ts

@@ -0,0 +1,132 @@
+/* Copyright © 2022-2026 Voxgig Ltd, MIT License. */
+
+// Lambda handler template: one handler source file per lambda service,
+// bootstrapping Seneca via the env folder and delegating to gateway-lambda.
+
+import { dive, get, pinify } from '@voxgig/util'
+
+import { MsgMetaShape } from '../../shape/msg'
+
+import { generate, loadFragment, renderFragment } from './generate'
+
+
+// Only create if does not exist
+const srv_handler = async (model: any, spec: {
+  folder: string
+  start?: string
+  env?: {
+    folder: string
+  }
+  lang?: string
+  tm?: string
+}) => {
+  let lang = spec.lang || 'js'
+
+  const frag = loadFragment('srv_handler.' + lang + '.frag', spec)
+
+  const files: { name: string, content: string }[] = []
+
+  Object
+    .entries(model.main.srv)
+    .filter((entry: any) => entry[1].env?.lambda)
+    .forEach((entry: any) => {
+      const name = entry[0]
+      const srv = entry[1]
+
+      if ('custom' === srv.env.lambda.kind) {
+        return
+      }
+
+      let start = spec.start || 'setup'
+      let envFolder = spec.env?.folder || '../../../env/lambda'
+
+      let handler = 'handler'
+      let modify = ''
+
+      //       if (!srv.api.web.active) {
+      //         if (srv.on && 0 < Object.keys(srv.on).length) {
+      //           handler = 'eventhandler'
+      //           modify = `
+      // event = {
+      //   ...event,
+      //   // TODO: @voxgig/system? util needed to handle this dynamically
+      //   seneca$: { msg: '${srv.on[Object.keys(srv.on)[0]].events[0].msg}' },
+      // }
+      //         `
+      //         }
+      //       }
+
+
+      let prepare = ''
+      let complete = ''
+
+
+      dive(model.main.msg.aim[name], 128).map((entry: any) => {
+        let path = ['aim', name, ...entry[0]]
+        let msgMeta = MsgMetaShape(entry[1])
+        let pin = pinify(path)
+        if (msgMeta.transport?.queue?.active) {
+          complete += `
+  seneca.listen({type:'sqs',pin:'${pin}'})`
+        }
+      })
+
+
+      dive(model.main.srv[name].out, 128).map((entry: any) => {
+        let path = entry[0]
+        let msgMetaMaybe = get(model.main.msg, path)
+        // console.log(name, path, msgMetaMaybe)
+        if (msgMetaMaybe?.$) {
+          let msgMeta = MsgMetaShape(msgMetaMaybe?.$)
+          let pin = pinify(path)
+
+          if (msgMeta.transport?.queue?.active) {
+            complete += `
+  seneca.client({type:'sqs',pin:'${pin}'})`
+          }
+        }
+      })
+
+      let makeGatewayHandler = false
+      let onlist = model.main.srv[name].on || {}
+      Object.entries(onlist).map((onitem: any) => {
+        onitem[1].events.map((event: any) => {
+          if ('s3' === event.source) {
+            if (!makeGatewayHandler) {
+              complete += `
+
+  const makeGatewayHandler = seneca.export('s3-store/makeGatewayHandler')`
+              makeGatewayHandler = true
+            }
+
+            complete += `
+  seneca
+    .act('sys:gateway,kind:lambda,add:hook,hook:handler', {
+       handler: makeGatewayHandler('${event.msg}') })`
+          }
+        })
+      })
+
+
+      const content = renderFragment(frag, {
+        envFolder,
+        start,
+        name,
+        complete,
+        modify,
+        prepare,
+        handler,
+      })
+
+      files.push({ name: name + '.' + lang, content })
+    })
+
+  if (0 < files.length) {
+    await generate(spec.folder, files)
+  }
+}
+
+
+export {
+  srv_handler,
+}

package/env/lambda/srv_yml.ts

@@ -0,0 +1,201 @@
+/* Copyright © 2022-2026 Voxgig Ltd, MIT License. */
+
+// gen/serverless/srv.yml template: one Serverless function definition per
+// lambda-active service, derived from the model.
+
+import Fs from 'fs'
+import Path from 'path'
+
+import { camelify } from '@voxgig/util'
+
+import { CoreConfShape } from '../../shape/conf'
+
+import { generate, empty, TM, loadFragment, renderFragment } from './generate'
+
+
+const srv_yml = async (model: any, spec: {
+  folder: string
+  tm?: string
+}) => {
+
+  const core = CoreConfShape(model.main.conf.core)
+
+  let appname = core.name
+  let AppName = camelify(appname)
+
+  const frag = loadFragment('srv.yml.frag', spec)
+
+  let srv_yml_prefix_path = Path.join(spec.folder, 'srv.prefix.yml')
+  let srv_yml_suffix_path = Path.join(spec.folder, 'srv.suffix.yml')
+
+  let prefixContent = Fs.existsSync(srv_yml_prefix_path) ?
+    Fs.readFileSync(srv_yml_prefix_path) : ''
+  let suffixContent = Fs.existsSync(srv_yml_suffix_path) ?
+    Fs.readFileSync(srv_yml_suffix_path) : ''
+
+  let content =
+
+    prefixContent +
+    Object
+      .entries(model.main.srv)
+      .filter((entry: any) => entry[1].env?.lambda?.active)
+      .map((entry: any) => {
+        const name = entry[0]
+        const srv = entry[1]
+
+        const lambda = srv.env.lambda
+        const handler = lambda.handler
+
+        // NOTE: gen.custom convention: allows for complete overwrite
+        // as a get-out-of-jail
+        if (srv.gen?.custom?.lambda?.srv_yml) {
+          return srv.gen.custom.lambda.srv_yml
+        }
+
+        const web = srv.api.web
+
+        let events = ''
+
+        let onEvents = srv.on
+
+        if (onEvents) {
+          Object.entries(onEvents).forEach((entry: any[]) => {
+            // let name = entry[0]
+            let spec = entry[1]
+
+            if ('aws' === spec.provider) {
+              spec.events.forEach((ev: any) => {
+                if ('s3' === ev.source) {
+                  events += TM(`
+    - s3:
+        bucket: ${ev.bucket}
+        event: ${ev.event}
+        existing: true
+`)
+                  if (ev.rules) {
+                    events += TM(`
+        rules:
+`)
+                    if (ev.rules.prefix) {
+                      events += TM(`
+          - prefix: ${ev.rules.prefix}
+`)
+                    }
+
+                    if (ev.rules.suffix) {
+                      events += TM(`
+          - suffix: ${ev.rules.suffix}
+`)
+                    }
+                  }
+                }
+                else if ('schedule' === ev.source) {
+                  let entries =
+                    'string' === typeof ev.recur ? [ev.recur] : (ev.recur || [])
+                  let recur = entries.map((entry: string) => {
+                    let schedule = `
+    - schedule:
+        rate: ${entry}`
+                    if (ev.msg) {
+                      schedule += `
+        input:
+          msg: ${JSON.stringify(ev.msg)} `
+                    }
+                    return schedule
+                  })
+
+                  events += TM(`
+${recur}
+`)
+
+                }
+                else if ('sqs' === ev.source) {
+                  events += TM(`
+    - sqs:
+        arn:
+          Fn::GetAtt:
+            - ${ev.qrn}
+            - Arn
+        batchSize: 1
+`)
+
+                }
+              })
+            }
+          })
+        }
+
+        // TODO: move to `on`
+        if (web.active) {
+          let prefix = web.path.prefix
+          let suffix = web.path.suffix
+          let area = web.path.area
+          let method = web.method
+          let corsflag = 'false'
+          let corsprops = ''
+
+          let methods = method.split(',')
+          // console.log('METHODS', methods)
+
+          if (web.cors.active) {
+            corsflag = 'true'
+            if (web.cors.props && !empty(web.cors.props)) {
+              corsflag = ''
+              corsprops = Object
+                .entries(web.cors.props)
+                .reduce(((a: any, nv: any) => (
+                  a += `          ${nv[0]}: ${nv[1]}\n`
+                  , a)), '')
+            }
+          }
+
+          if ('v2' === web.lambda?.gateway) {
+            for (let method of methods) {
+              events += TM(`
+    - httpApi:
+        path: "${prefix}${area}${name}${suffix}"
+        method: ${method}
+`)
+            }
+          }
+          else {
+            for (let method of methods) {
+              events += TM(`
+    - http:
+        path: "${prefix}${area}${name}${suffix}"
+        method: ${method}
+        cors: ${corsflag}
+${corsprops}
+`)
+            }
+          }
+        }
+
+
+
+        let eventsBlock = ''
+        if ('' !== events) {
+          eventsBlock = TM(`
+  events:
+${events}
+`)
+        }
+
+        return renderFragment(frag, {
+          name,
+          handler: handler.path.prefix + name + handler.path.suffix,
+          AppName,
+          timeout: lambda.timeout,
+          memory: lambda.memory || 1024,
+          events: eventsBlock,
+        })
+      }).join('\n\n\n') +
+    suffixContent
+
+  await generate(spec.folder, [{ name: 'srv.yml', content }])
+}
+
+
+export {
+  srv_yml,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voxgig/build",
-  "version": "3.1.0",
+  "version": "4.1.0",
   "main": "dist/build.js",
   "type": "commonjs",
   "types": "dist/build.d.ts",
@@ -18,7 +18,7 @@
     "url": "git://github.com/voxgig/build.git"
   },
   "scripts": {
-    "model-s01": "voxgig-model test/s01/model/model.jsonic",
+    "model-s01": "voxgig-model test/s01/model/model.aontu",
     "test": "jest --coverage",
     "test-some": "jest -t",
     "test-watch": "jest --coverage --watchAll",
@@ -28,7 +28,13 @@
     "reset": "npm run clean && npm i && npm run build && npm test",
     "repo-tag": "REPO_VERSION=`node -e \"console.log(require('./package').version)\"` && echo TAG: v$REPO_VERSION && git commit -a -m v$REPO_VERSION && git push && git tag v$REPO_VERSION && git push --tags;",
     "repo-publish": "npm run clean && npm i && npm run repo-publish-quick",
-    "repo-publish-quick": "npm run build && npm run test && npm run repo-tag && npm publish --registry https://registry.npmjs.org --access=public"
+    "repo-publish-quick": "npm run build && npm run test && npm run repo-tag && npm run repo-stage-publish",
+    "repo-stage-publish": "aql vault exec --for=npm vxg:pub01 -- npm stage publish --registry https://registry.npmjs.org --access=public",
+    "repo-stage-publish-dry": "aql vault exec --dry-run --for=npm vxg:pub01 -- npm stage publish --registry https://registry.npmjs.org --access=public --dry-run",
+    "repo-stage-list": "aql vault exec --for=npm vxg:pub01 -- npm stage list",
+    "repo-stage-view": "aql vault exec --for=npm vxg:pub01 -- npm stage view",
+    "repo-stage-approve": "aql vault exec --for=npm vxg:pub01 -- npm stage approve",
+    "repo-stage-reject": "aql vault exec --for=npm vxg:pub01 -- npm stage reject"
   },
   "license": "MIT",
   "files": [
@@ -36,17 +42,21 @@
     "lib",
     "dist",
     "bin",
-    "LICENSE"
+    "LICENSE",
+    "tm",
+    "env"
   ],
   "dependencies": {
-    "gubu": "^8.0.2",
+    "@voxgig/util": "0.5.4",
+    "gubu": "8.0.2",
+    "jostraca": "0.31.2",
     "js-yaml": "^4.1.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "20.14.10",
-    "@voxgig/model": "^2.1.0",
+    "@types/node": "26.1.2",
+    "@voxgig/model": "^9.2.4",
     "@voxgig/system": "^1.2.0",
     "esbuild": "^0.23.0",
     "jest": "^29.7.0",

package/tm/lambda/res.queue.yml.frag

@@ -0,0 +1,6 @@
+$$resname$$:
+  Type: "AWS::SQS::Queue"
+  Properties:
+    QueueName: '$$queueName$$'
+    VisibilityTimeout: $$queueTimeout$$
+

package/tm/lambda/res.role.yml.frag

@@ -0,0 +1,35 @@
+
+Basic$$AppName$$LambdaRole:
+  Type: AWS::IAM::Role
+  Properties:
+    RoleName: Basic$$AppName$$LambdaRole${self:custom.index.BasicLambdaRole,"01"}
+    AssumeRolePolicyDocument:
+      Version: '2012-10-17'
+      Statement:
+        - Effect: Allow
+          Principal:
+            Service:
+              - lambda.amazonaws.com
+              - events.amazonaws.com
+              - ecs-tasks.amazonaws.com
+          Action: sts:AssumeRole
+    Policies:
+      - PolicyName: LambdaServiceAccess
+        PolicyDocument:
+          Version: '2012-10-17'
+          Statement:
+            - Effect: Allow
+              Action:
+                - dynamodb:DescribeTable
+                - dynamodb:GetItem
+                - dynamodb:PutItem
+                - dynamodb:UpdateItem
+                - dynamodb:DeleteItem
+                - dynamodb:Query
+                - dynamodb:Scan
+              Resource: 
+$$dynamoArns$$
+$$customPolicy$$
+    ManagedPolicyArns:
+      - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
+

package/tm/lambda/srv.yml.frag

@@ -0,0 +1,6 @@
+$$name$$:
+  handler: $$handler$$
+  role: Basic$$AppName$$LambdaRole
+  timeout: $$timeout$$
+  memorySize: $$memory$$
+$$events$$

package/tm/lambda/srv_handler.js.frag

@@ -0,0 +1,17 @@
+const getSeneca = require('$$envFolder$$/$$start$$')
+
+function complete(seneca: any) {$$complete$$
+}
+
+exports.handler = async (
+  event,
+  context
+) => {
+  $$modify$$
+  let seneca = await getSeneca('$$name$$', complete)
+  $$prepare$$
+  let handler = seneca.export('gateway-lambda/$$handler$$')
+  let res = await handler(event, context)
+  return res
+}
+

package/tm/lambda/srv_handler.ts.frag

@@ -0,0 +1,17 @@
+import { getSeneca } from '$$envFolder$$/$$start$$'
+
+function complete(seneca: any) {$$complete$$
+}
+
+exports.handler = async (
+  event:any,
+  context:any
+) => {
+  $$modify$$
+  let seneca = await getSeneca('$$name$$', complete)
+  $$prepare$$
+  let handler = seneca.export('gateway-lambda/$$handler$$')
+  let res = await handler(event, context)
+  return res
+}
+