@voxgig/build 3.1.0 → 4.1.0

package/build.ts

@@ -1,496 +1,63 @@
-/* Copyright © 2022 Voxgig Ltd, MIT License. */
-
-import Fs from 'fs'
-import Path from 'path'
-
-import { dive, get, pinify, camelify } from '@voxgig/util'
+/* Copyright © 2022-2026 Voxgig Ltd, MIT License. */
+
+// EnvLambda: generation of the Lambda deployment templates, built on the
+// jostraca templating library. The templates live in env/lambda/, one file
+// per output for convenience:
+//
+//   env/lambda/srv_yml.ts      gen srv.yml    (Serverless function defs)
+//   env/lambda/srv_handler.ts  handler source (one per lambda service)
+//   env/lambda/res_yml.ts      gen res.yml    (queues, dynamo, IAM role)
+//
+// The output is byte-identical to the pre-jostraca (<= 3.1.0) generator;
+// test/fixture pins this. All generators are async (jostraca generation is
+// async); existing callers that did not await still work, as the writes
+// complete before the process exits.
+
+import { srv_yml } from './env/lambda/srv_yml'
+import { srv_handler } from './env/lambda/srv_handler'
+import { resources_yml } from './env/lambda/res_yml'
+
+import {
+  generate, empty, TM,
+  loadFragment, renderFragment, listFragments, PKG_TM,
+} from './env/lambda/generate'
 
 import { MsgMetaShape } from './shape/msg'
 import { CoreConfShape, CloudConfShape } from './shape/conf'
-
 import { res_dynamo_yml } from './yml/res_dynamo_yml'
 
 
-// console.log('BUILD 1')
-
 const EnvLambda = {
-
-  srv_yml: (model: any, spec: {
-    folder: string
-  }) => {
-
-    const core = CoreConfShape(model.main.conf.core)
-
-    let appname = core.name
-    let AppName = camelify(appname)
-
-    let srv_yml_path = Path.join(spec.folder, 'srv.yml')
-
-    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
-          }
-
-          // TODO: this should be a JSON structure exported as YAML
-          let srvyml = `${name}:
-  handler: ${handler.path.prefix}${name}${handler.path.suffix}
-  role: Basic${AppName}LambdaRole
-  timeout: ${lambda.timeout}
-  memorySize: ${lambda.memory || 1024}
-`
-          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}
-`)
-              }
-            }
-          }
-
-
-
-          if ('' !== events) {
-            srvyml += TM(`
-  events:
-${events}
-`)
-          }
-
-
-          return srvyml
-        }).join('\n\n\n') +
-      suffixContent
-
-    Fs.writeFileSync(srv_yml_path, content)
-  },
-
-
-  // Only create if does not exist
-  srv_handler: (model: any, spec: {
-    folder: string
-    start?: string
-    env?: {
-      folder: string
-    }
-    lang?: string
-  }) => {
-    let lang = spec.lang || 'js'
-    let TS = 'ts' === lang
-
-    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 srv_handler_path = Path.join(spec.folder, name + '.' + lang)
-
-        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}') })`
-            }
-          })
-        })
-
-
-        let content =
-          TS ? `import { getSeneca } from '${envFolder}/${start}'`
-            :
-            `const getSeneca = require('${envFolder}/${start}')`
-
-        content += `
-
-function complete(seneca: any) {${complete}
-}
-
-exports.handler = async (
-  event${TS ? ':any' : ''},
-  context${TS ? ':any' : ''}
-) => {
-  ${modify}
-  let seneca = await getSeneca('${name}', complete)
-  ${prepare}
-  let handler = seneca.export('gateway-lambda/${handler}')
-  let res = await handler(event, context)
-  return res
+  srv_yml,
+  srv_handler,
+  resources_yml,
 }
-`
-
-        // TODO: make this an option
-        //if (!Fs.existsSync(srv_handler_path)) {
-        Fs.writeFileSync(srv_handler_path, content)
-      })
-  },
-
-
-  resources_yml: async (model: any, spec: {
-    folder: string,
-    filename: string
-    custom: string,
-  }) => {
-
-    const core = CoreConfShape(model.main.conf.core)
-
-    const appname = core.name
-    const AppName = camelify(appname)
-
-    const cloud = CloudConfShape(model.main.conf.cloud)
-
-    const region = cloud.aws.region
-    const accountid = cloud.aws.accountid
-
-    let filename = spec.filename || 'resources.yml'
-    let resources_yml_path = Path.join(spec.folder, filename)
-
-    let resources_yml_prefix_path = Path.join(spec.folder, 'res.prefix.yml')
-    let resources_yml_suffix_path = Path.join(spec.folder, 'res.suffix.yml')
-
-    let prefixContent = Fs.existsSync(resources_yml_prefix_path) ?
-      Fs.readFileSync(resources_yml_prefix_path) : ''
-    let suffixContent = Fs.existsSync(resources_yml_suffix_path) ?
-      Fs.readFileSync(resources_yml_suffix_path) : ''
-
-    const dynamoResources: { arn: string }[] = []
-
-    let content =
-      `# START
-`
-
-    content +=
-      prefixContent +
-
-      await res_dynamo_yml(model, { dynamoResources, region, accountid })
-
-    // content +=
-    let queueDefs = dive(model.main.msg, 128).map((entry: any) => {
-      let path = entry[0]
-      let msgMeta = MsgMetaShape(entry[1])
-
-      let pathname = path
-        .map((p: string) =>
-          (p[0] + '').toUpperCase() + p.substring(1))
-        .join('')
-
-      // console.log('MQ', pathname, msgMeta)
-
-      if (msgMeta.transport?.queue?.active) {
-        // console.log('MM', path, msgMeta)
-        let queue = msgMeta.transport.queue
-        let name = queue.name || pathname
-
-        // TODO: aontu should do this, but needs recursive child conjuncts
-        let stage_suffix =
-          (false === queue.stage?.active) ? '' : '-${self:provider.stage,"dev"}'
-
-        let queue_suffix = (null == queue.suffix || '' == queue.suffix) ? '' :
-          '-' + queue.suffix
-
-        let resname = 'Queue' + name
-
-        let queueName =
-          (queue.prefix || '') +
-          path.reduce((s: string, p: string, i: number) =>
-          (s += p + (i % 2 ?
-            (i == path.length - 1 ? '' : '-') : '_')), '') +
-          (queue_suffix || '') +
-          (stage_suffix || '')
-
-        let queueTimeout = queue.timeout || 30
-
-        return `${resname}:
-  Type: "AWS::SQS::Queue"
-  Properties:
-    QueueName: '${queueName}'
-    VisibilityTimeout: ${queueTimeout}
-`
-      }
-      return ''
-    }).filter(n => '' !== n).join('')
-
-    // console.log('queueDefs', queueDefs)
-
-    content += '\n\n' + queueDefs
-
-    let customLambdaPolicyStatementPath =
-      Path.join(spec.folder, 'res.lambda.policy.statements.yml')
-    let customLambdaPolicyStatementContent = Fs.existsSync(customLambdaPolicyStatementPath) ?
-      Fs.readFileSync(customLambdaPolicyStatementPath) : ''
-
-
-
-    content += `
-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: 
-${dynamoResources.map(r => '                - ' + r.arn).join('\n')}
-${customLambdaPolicyStatementContent}
-    ManagedPolicyArns:
-      - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
-`
-
-
-
-    if (spec.custom) {
-      content = Fs.readFileSync(spec.custom).toString() + '\n\n\n' + content
-    }
-
-    content += suffixContent
-
-    content += `
-# END
-`
-
-    Fs.writeFileSync(resources_yml_path, content)
-  },
-
 
 
+// Fragment tooling (used by voxgig-system template list/eject/diff, and
+// available to project code).
+const Fragments = {
+  load: loadFragment,
+  render: renderFragment,
+  list: listFragments,
+  folder: PKG_TM,
 }
 
 
-
-
-
-
-function empty(o: any) {
-  return null == o ? true : 0 === Object.keys(o).length
-}
-
-// Strip inital newline
-function TM(str: string) {
-  return str.replace(/^\n/, '')
-}
-
-
-
 export {
   EnvLambda,
+  Fragments,
+
+  // Building blocks for ejected project templates (src/gen/<name>.ts
+  // copies import these from '@voxgig/build' instead of package
+  // internals - see voxgig-system template eject --code).
+  generate,
+  empty,
+  TM,
+  loadFragment,
+  renderFragment,
+  MsgMetaShape,
+  CoreConfShape,
+  CloudConfShape,
+  res_dynamo_yml,
 }
-
-

package/dist/build.d.ts

@@ -1,7 +1,12 @@
+import { generate, empty, TM, loadFragment, renderFragment, listFragments } from './env/lambda/generate';
+import { MsgMetaShape } from './shape/msg';
+import { CoreConfShape, CloudConfShape } from './shape/conf';
+import { res_dynamo_yml } from './yml/res_dynamo_yml';
 declare const EnvLambda: {
     srv_yml: (model: any, spec: {
         folder: string;
-    }) => void;
+        tm?: string;
+    }) => Promise<void>;
     srv_handler: (model: any, spec: {
         folder: string;
         start?: string;
@@ -9,11 +14,19 @@ declare const EnvLambda: {
             folder: string;
         };
         lang?: string;
-    }) => void;
+        tm?: string;
+    }) => Promise<void>;
     resources_yml: (model: any, spec: {
         folder: string;
         filename: string;
         custom: string;
+        tm?: string;
     }) => Promise<void>;
 };
-export { EnvLambda, };
+declare const Fragments: {
+    load: typeof loadFragment;
+    render: typeof renderFragment;
+    list: typeof listFragments;
+    folder: string;
+};
+export { EnvLambda, Fragments, generate, empty, TM, loadFragment, renderFragment, MsgMetaShape, CoreConfShape, CloudConfShape, res_dynamo_yml, };