@tremho/mist-lift 2.2.8 → 2.4.0

package/src/lib/executeCommand.ts

@@ -13,7 +13,7 @@ export async function executeCommand (cmd: string, args: any[], cwd = '', consol
   }
   return await new Promise(resolve => {
     const cmdstr = cmd + ' ' + args.join(' ')
-    // console.log('executing ', cmdstr, 'at', cwd)
+    // console.log('executing ', cmdstr, 'at', cwd, {consolePass})
     const opts = {
       cwd,
       env: Object.assign(env, process.env)

package/src/lib/openAPI/openApiConstruction.ts

@@ -6,14 +6,21 @@ import fs from 'fs'
 import path from 'path'
 import { resolvePaths } from '../pathResolve'
 import * as ac from 'ansi-colors'
+import { decoratedName, getAccountId } from '../IdSrc'
+import { getAWSCredentials, getSettings } from '../LiftConfig'
+import { parseConstraints, TypeConstraint } from '../TypeCheck'
+import yaml from 'js-yaml'
 
 export async function buildOpenApi (
   defs: any[],
   includePrivate: boolean = false,
+  includeCORS: boolean = false,
   yamlFile?: string
 ): Promise<Uint8Array> {
   const builder = new OpenApiBuilder()
 
+  // console.log("buildOpenApi to "+yamlFile)
+
   const projectPaths = await resolvePaths()
   if (!projectPaths.verified) return new Uint8Array(0) // don't continue if not valid
 
@@ -67,12 +74,14 @@ export async function buildOpenApi (
       addTypeSchema(builder, schemaName, schema)
     }
     method = method.trim().toLowerCase()
-    addFunctionMethod(pathDef, method, def)
+    await addFunctionMethod(pathDef, method, def, includeCORS)
     for (const param of parameters) {
       addParameter(pathDef, param)
     }
-    addCORSOptionMethod(pathDef)
-    const pathMap = def.pathMap ?? '/' + (def.name as string)
+    if (includeCORS) addCORSOptionMethod(pathDef)
+    let pathMap = def.pathMap ?? '/' + (def.name as string)
+    pathMap = pathMap.replace('?', '')
+
     // pathMap = stagePathSegment + pathMap
     builder.addPath(pathMap, pathDef)
 
@@ -93,72 +102,230 @@ export async function buildOpenApi (
     return bufView
   }
 
-  const yaml = builder.getSpecAsYaml()
-  const bytes = str2ab(yaml)
-  if (!includePrivate) {
-    fs.writeFileSync(outFile, yaml)
-  }
+  const spec = builder.getSpec()
+  spec['x-amazon-apigateway-binary-media-types'] = [
+    'application/octet-stream',
+    'image/*',
+    'audio/*'
+  ]
+  const yamlSpec = yaml.dump(spec)
+  const bytes = str2ab(yamlSpec)
+  // if (!includePrivate) {
+  fs.writeFileSync(outFile, yamlSpec)
+  // }
   return bytes
 }
 
 function addTypeSchema (builder: any, schemaName: string, schema: any): void {
-  const ref: any = { title: schemaName, type: 'object', properties: {} }
-  for (const prop of Object.getOwnPropertyNames(schema)) {
-    const scType: any = schemaType('', schema[prop], false)
-
-    ref.properties[prop] = scType
+  let primType = ''
+  let type = schema?.type ?? 'Empty'
+  if (type === 'empty') type = 'Empty' // fix case
+  const isArray = (type.endsWith('[]'))
+  if (isArray) type = type.substring(0, type.length - 2)
+  if (type === 'string' || type === 'number' || type === 'object') primType = type
+  const mime = schema?.mime ?? primType ? 'text/plain' : 'application/json'
+  const sref = primType ? { type: primType } : { $ref: '#/components/schemas/' + type }
+  let ref: any = {}
+  if (isArray) {
+    ref = { type: 'array', items: sref }
+  } else {
+    ref = sref
   }
 
+  ref.title = schemaName
+
+  if (ref.type === 'object') ref.properties = {}
+
+  const constraints = schema.type !== 'object' && Array.isArray(schema?.constraints) ? parseConstraints(schema.type, schema.constraints.join('\n'), '\n') : undefined
+
+  const cdesc = (constraints != null) ? '\n  - ' + (constraints.describe() ?? '').split('\n').join('\n  - ') : ''
+  let description = schema.description
+  if (cdesc) description += cdesc
+
+  ref.description = description
+
+  const required: string[] = []
+
+  if (ref.properties) {
+    for (const [propName, propDef] of Object.entries(schema.properties || {})) {
+      const pda = propDef as any
+      const constraints = Array.isArray(pda?.constraints) ? parseConstraints(pda.type, pda.constraints.join('\n'), '\n') : undefined
+
+      const cdesc = (constraints != null) ? '\n  - ' + (constraints.describe() ?? '').split('\n').join('\n  - ') : ''
+      let description = (propDef as any).description
+      if (cdesc) description += cdesc
+
+      // if(constraints) {
+      //   console.log("schema definition for "+schemaName+', prop '+propName)
+      //   console.log(description)
+      // }
+
+      const propSchema: any = {
+        type: (propDef as any).type,
+        description
+      }
+
+      // You can add other custom handling here (e.g., enums, format, pattern)
+      ref.properties[propName] = propSchema
+
+      // Only mark as required if declared explicitly
+      if (schema.required && schema.required.includes(propName)) {
+        required.push(propName)
+      }
+    }
+
+    if (required.length > 0) {
+      ref.required = required
+    }
+  }
   builder.addSchema(schemaName, ref)
 }
 
-function addFunctionMethod (pathDef: any, method: string, def: any): void {
-  // TODO: Define a return schema and put that here
+async function addFunctionMethod (pathDef: any, method: string, def: any, includeCORS = true): Promise<void> {
   const retDef: any = (def.returns)['200']
   const content: any = {}
-  const mime = retDef?.content ?? retDef?.mime ?? 'text/plain'
+  let primType = ''
+  let type = retDef?.type ?? 'Empty'
+  if (type === 'empty') type = 'Empty' // fix case
+  const isArray = (type.endsWith('[]'))
+  if (isArray) type = type.substring(0, type.length - 2)
+  if (type === 'string' || type === 'number' || type === 'object') primType = type
+  const mime = retDef?.mime ?? primType ? 'text/plain' : 'application/json'
+  const ref = primType ? { type: primType } : { $ref: '#/components/schemas/' + type }
+  let schema: any
+  if (isArray) {
+    schema = { type: 'array', items: ref }
+  } else {
+    schema = ref
+  }
   content[mime] = {
+    schema
   }
 
+  const region = getSettings()?.awsPreferredRegion ?? ''
+  const accountId = await getAccountId()
+  const decName = decoratedName(def.name)
+
+  const isBinary = def.bodyType && !def.bodyType.startsWith('text') && !def.bodyType.endsWith('json')
+
   const methData = {
     summary: def.name,
     description: def.description,
     responses: {
       200: {
         description: retDef?.description ?? 'Success Response',
+        headers: includeCORS
+          ? {
+              'Access-Control-Allow-Origin': {
+                schema: {
+                  type: 'string'
+                },
+                example: '*'
+              },
+              'Access-Control-Allow-Headers': {
+                schema: {
+                  type: 'string'
+                },
+                example: 'Content-Type, Authorization'
+              },
+              'Access-Control-Allow-Methods': {
+                schema: {
+                  type: 'string'
+                },
+                example: 'GET,POST,PUT,OPTIONS'
+              }
+            }
+          : undefined,
         content
       }
+    },
+    'x-amazon-apigateway-integration': {
+      uri: `arn:aws:apigateway:${region}:lambda:path/2015-03-31/functions/arn:aws:lambda:${region}:${accountId}:function:${decName}/invocations`,
+      passthroughbehavior: 'when_no_match',
+      contentHandling: isBinary ? 'CONVERT_TO_BINARY' : undefined,
+      httpMethod: 'POST', // always POST - this is how API gateway calls Lambda, not the method of the api
+      type: 'aws_proxy'
     }
   }
+
+  if (!includeCORS) {
+    // get the other response code declarations
+    for (const rcode of Object.getOwnPropertyNames(def.returns)) {
+      if (rcode != '200') {
+        const retDef = def.returns[rcode] ?? {}
+
+        const content: any = {}
+        let primType = ''
+        let type = retDef?.type ?? 'Empty'
+        if (type === 'empty') type = 'Empty' // fix case
+        const isArray = (type.endsWith('[]'))
+        if (isArray) type = type.substring(0, type.length - 2)
+        if (type === 'string' || type === 'number' || type === 'object') primType = type
+        const mime = retDef?.mime ?? primType ? 'text/plain' : 'application/json'
+        const ref = primType ? { type: primType } : { $ref: '#/components/schemas/' + type }
+        let schema: any
+        if (isArray) {
+          schema = { type: 'array', items: ref }
+        } else {
+          schema = ref
+        }
+        content[mime] = {
+          schema
+        }
+        retDef.content = content;
+        (methData.responses as any)[rcode] = retDef
+      }
+    }
+  }
+
   pathDef[method] = methData
 }
 function addCORSOptionMethod (pathDef: any): void {
-  if (pathDef.options === undefined) return // already assinged by definition
+  // if (pathDef.options === undefined) return // already assinged by definition
   // add options for CORS
   pathDef.options = {
+    summary: 'CORS support',
     responses: {
       200: {
-        description: '200 response',
-        content: {
-          'application/json': {
+        description: 'CORS response',
+        headers: {
+          'Access-Control-Allow-Origin': {
             schema: {
-              $ref: '#/components/schemas/Empty'
-            }
+              type: 'string'
+            },
+            example: '*'
+          },
+          'Access-Control-Allow-Methods': {
+            schema: {
+              type: 'string'
+            },
+            example: 'GET,POST,PUT,OPTIONS'
+          },
+          'Access-Control-Allow-Headers': {
+            schema: {
+              type: 'string'
+            },
+            example: 'Content-Type, Authorization'
           }
         }
       }
     },
     'x-amazon-apigateway-integration': {
+      type: 'mock',
+      requestTemplates: {
+        'application/json': '{"statusCode": 200}'
+      },
       responses: {
         default: {
-          statusCode: '200'
+          statusCode: '200',
+          responseParameters: {
+            'method.response.header.Access-Control-Allow-Origin': "'*'",
+            'method.response.header.Access-Control-Allow-Methods': "'GET, POST, PUT, OPTIONS'",
+            'method.response.header.Access-Control-Allow-Headers': "'Content-Type, Authorization'"
+          }
         }
       },
-      requestTemplates: {
-        'application/json': '{"statusCode": 200}'
-      },
-      passthroughBehavior: 'when_no_match',
-      type: 'mock'
+      passthroughBehavior: 'when_no_match'
     }
   }
 }
@@ -166,21 +333,37 @@ function addCORSOptionMethod (pathDef: any): void {
 function addParameter (pathDef: any, param: any): void {
   if (pathDef.parameters === undefined) pathDef.parameters = []
   const parameters = pathDef.parameters
-  const example = param.example ?? param.default ?? ''
-  const type = param.type ?? typeof example
-  const deflt = param.default ?? example
-
-  parameters.push({
-    in: param.in,
-    name: param.name,
-    description: param.description,
-    example,
-    required: param.required,
-    schema: schemaType(deflt, type, true)
-  })
+  const example = param.example ?? ''
+  const type = param.type ?? 'string'
+  const deflt = param.default ?? ''
+
+  // parameter is always required if it comes from path
+  // never required if it comes from query
+  // and may or may not be if it comes from body (per def)
+  const src = param?.in?.trim().toLowerCase() ?? ''
+  let required = (src === 'path')
+  if (src === 'body') required = param.required ?? false
+
+  const constraints = Array.isArray(param.constraints) ? parseConstraints(param.type, param.constraints.join('\n'), '\n') : undefined
+
+  const cdesc = (constraints != null) ? '\n  - ' + (constraints.describe() ?? '').split('\n').join('\n  - ') : ''
+  let description = param.description
+  if (cdesc) description += cdesc
+
+  // don't declare parameters marked as 'body'.  OpenAPI doesn't support that.
+  if (param.in === 'path' || param.in === 'query') {
+    parameters.push({
+      in: param.in,
+      name: param.name,
+      description,
+      example: example || undefined,
+      required,
+      schema: schemaType(deflt, type, true)
+    })
+  }
 }
 
-function schemaType (deflt: string, namedType: string, innerOnly: boolean): any {
+function schemaType (deflt: string | undefined, namedType: string, innerOnly: boolean): any {
   if (typeof namedType === 'object') return namedType
   const typeFormat = namedType.split(':')
   let type = typeFormat[0]
@@ -204,5 +387,6 @@ function schemaType (deflt: string, namedType: string, innerOnly: boolean): any
   }
   if (type === 'int') type = 'integer'
   if (type === 'bool') type = 'boolean'
+  if (!deflt) deflt = undefined
   return innerOnly ? { type, format, example: deflt } : { schema: { type, format, example: deflt } }
 }

package/src/lift.ts

@@ -64,7 +64,7 @@ async function processCommand (): Promise<void> {
     }
       return
     case 'publish': {
-      const ret = await doPublishAsync()
+      const ret = await doPublishAsync(args)
       process.exit(ret)
     }
       return

package/templateData/function-main-ts

@@ -1,4 +1,11 @@
-import {LambdaApi, Success, NotFound, NotImplemented, ServerError} from "@tremho/inverse-y"
+import {
+    LambdaApi,
+    getAssetUrl,
+    Success,
+    NotFound,
+    NotImplemented,
+    ServerError,
+} from "@tremho/inverse-y"
 import fs from "fs"
 import path from 'path'
 import {Log} from "@tremho/inverse-y"