@digitraffic/common 2024.8.30-1 → 2024.9.24-3

package/dist/__test__/infra/api/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__test__/infra/api/integration.test.js

@@ -0,0 +1,135 @@
+import { DigitrafficIntegration } from "../../../aws/infra/api/integration.js";
+import { Code, Function, Runtime } from "aws-cdk-lib/aws-lambda";
+import { App, Stack } from "aws-cdk-lib";
+import { MediaType } from "../../../aws/types/mediatypes.js";
+import velocity from "velocityjs";
+describe("integration tests", () => {
+    function createTemplate(i) {
+        const template = i.createRequestTemplates()[MediaType.APPLICATION_JSON].trim();
+        // assert template parses
+        const response = createResponseFromTemplate(template);
+        // assert response parses
+        console.info("response " + response);
+        return JSON.parse(response);
+    }
+    function createResponseFromTemplate(template) {
+        console.info("compile " + template);
+        const compile = new velocity.Compile(velocity.parse(template));
+        return compile.render({
+            method: {
+                request: {
+                    multivaluequerystring: {
+                        m1: ["multi1", "multi2"]
+                    }
+                }
+            },
+            input: {
+                path: () => ({}),
+                params: () => ({
+                    p1: "path1",
+                    q1: "query1",
+                    q2: "query2",
+                    h1: "header1",
+                    querystring: {
+                        qs1: "querystring1",
+                        qs2: "querystring2"
+                    }
+                })
+            },
+            util: {
+                base64Decode: (data) => Buffer.from(data, "base64").toString(),
+                escapeJavaScript: (data) => encodeURIComponent(data),
+                parseJson: (data) => JSON.stringify(data)
+            },
+            context: {
+                c1: "context1"
+            }
+        });
+    }
+    function createIntegration() {
+        const app = new App();
+        const stack = new Stack(app);
+        const f = new Function(stack, "id", {
+            runtime: Runtime.NODEJS_20_X,
+            code: Code.fromInline("placeholder"),
+            handler: "handler",
+        });
+        return new DigitrafficIntegration(f);
+    }
+    test("no parameters", () => {
+        const i = createIntegration();
+        const t = createTemplate(i);
+        expect(t).toEqual({});
+    });
+    test("query parameter", () => {
+        const i = createIntegration()
+            .addQueryParameter("q1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            q1: "query1"
+        });
+    });
+    test("multivaluequery parameter", () => {
+        const i = createIntegration()
+            .addMultiValueQueryParameter("m1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            m1: ["multi1", "multi2"]
+        });
+    });
+    test("all parameters", () => {
+        const i = createIntegration()
+            .passAllQueryParameters();
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            qs1: "querystring1",
+            qs2: "querystring2"
+        });
+    });
+    test("path parameter", () => {
+        const i = createIntegration()
+            .addPathParameter("p1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            p1: "path1"
+        });
+    });
+    test("context parameter", () => {
+        const i = createIntegration()
+            .addContextParameter("c1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            c1: "context1"
+        });
+    });
+    test("all parameters and header", () => {
+        const i = createIntegration()
+            .passAllQueryParameters()
+            .addHeaderParameter("h1");
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            "h1": "header1",
+            qs1: "querystring1",
+            qs2: "querystring2"
+        });
+    });
+    test("all parameters & parameter - fail", () => {
+        expect(() => {
+            createIntegration()
+                .passAllQueryParameters()
+                .addQueryParameter("q1");
+        }).toThrow();
+    });
+    test("path parameters & pass all ", () => {
+        const i = createIntegration()
+            .addPathParameter("p1")
+            .passAllQueryParameters();
+        const t = createTemplate(i);
+        expect(t).toEqual({
+            p1: "path1",
+            qs1: "querystring1",
+            qs2: "querystring2"
+        });
+    });
+});
+//# sourceMappingURL=integration.test.js.map

package/dist/__test__/infra/api/response.test.js

@@ -1,6 +1,5 @@
 import { RESPONSE_DEFAULT_LAMBDA } from "../../../aws/infra/api/response.js";
 import etag from "etag";
-//const velocity = require("velocityjs");
 import velocity from "velocityjs";
 const TEST_BODY = "Hello world!";
 describe("response tests", () => {

package/dist/aws/infra/acl-builder.js

@@ -183,7 +183,9 @@ export class AclBuilder {
                 sampledRequestsEnabled: false,
             },
             rules,
-            customResponseBodies: this._customResponseBodies,
+            ...(this._customResponseBodies && {
+                customResponseBodies: this._customResponseBodies,
+            }),
         });
     }
 }

package/dist/aws/infra/api/integration.js

@@ -1,11 +1,9 @@
 import { LambdaIntegration, PassthroughBehavior } from "aws-cdk-lib/aws-apigateway";
 import { MediaType } from "../../types/mediatypes.js";
 import { DigitrafficIntegrationResponse } from "../../runtime/digitraffic-integration-response.js";
-const VELOCITY_ALL_PARAMS = `#set($params = $input.params().get("querystring"))
-#foreach($paramName in $params.keySet())
-  "$paramName":"$util.escapeJavaScript($params.get($paramName))" #if($foreach.hasNext),#end
-#end
-`;
+const VELOCITY_ALL_PARAMS = `#foreach($paramName in $params.keySet())
+    #set($tmp = $paramMap.put($paramName, $params[$paramName]))
+#end`;
 export class DigitrafficIntegration {
     lambda;
     mediaType;
@@ -82,24 +80,35 @@ export class DigitrafficIntegration {
     }
     createRequestTemplates() {
         const parameterAssignments = [];
-        if (this._passAllQueryParameters) {
-            parameterAssignments.push(VELOCITY_ALL_PARAMS);
-        }
         this.parameters.forEach((parameter) => {
             if (parameter.type === "context") {
-                parameterAssignments.push(`"${parameter.name}":"$util.parseJson($context.${parameter.name}"`);
+                parameterAssignments.push(`#set($tmp = $paramMap.put('${parameter.name}', $util.escapeJavaScript($context['${parameter.name}'])))`);
             }
             else if (parameter.type === "multivaluequerystring") {
                 // make multivaluequerystring values to array
-                parameterAssignments.push(`"${parameter.name}":[#foreach($val in $method.request.multivaluequerystring.get('${parameter.name}'))"$util.escapeJavaScript($val)"#if($foreach.hasNext),#end#end]`);
+                parameterAssignments.push(`#set($tmp = $paramMap.put('_${parameter.name}', $util.parseJson($method.request.multivaluequerystring['${parameter.name}'])))`);
             }
             else {
-                parameterAssignments.push(`"${parameter.name}":"$util.escapeJavaScript($input.params('${parameter.name}'))"`);
+                parameterAssignments.push(`#set($tmp = $paramMap.put('${parameter.name}', $util.escapeJavaScript($input.params()['${parameter.name}'])))`);
             }
         });
+        // parameters starting with _ will be handled as json, and will not be in quotes
+        // (for example multivalueparameters)
         return {
-            [MediaType.APPLICATION_JSON]: `{
-    ${parameterAssignments.length > 0 ? parameterAssignments.join(",\n    ") + "\n" : ""}}`,
+            [MediaType.APPLICATION_JSON]: `
+#set($paramMap = {})
+#set($params = $input.params().get("querystring"))
+${parameterAssignments.join("\n")}
+${this._passAllQueryParameters ? VELOCITY_ALL_PARAMS : ""}
+{
+#foreach($paramName in $paramMap.keySet())
+#if( $paramName[0] != '_')
+    "$paramName":"$paramMap.get($paramName)" #if($foreach.hasNext),\n#end
+#else
+    "$paramName.substring(1)":$paramMap.get($paramName) #if($foreach.hasNext),\n#end
+#end
+#end
+}`,
         };
     }
     createResponses() {

package/dist/aws/infra/api/static-integration.d.ts

@@ -1,4 +1,4 @@
-import { type IntegrationResponse, MockIntegration, type Resource } from "aws-cdk-lib/aws-apigateway";
+import { type IntegrationResponse, type MethodResponse, MockIntegration, type Resource } from "aws-cdk-lib/aws-apigateway";
 import { MediaType } from "../../types/mediatypes.js";
 /**
  * Static integration, that returns the given response with given mediaType from given resource.
@@ -11,8 +11,5 @@ export declare class DigitrafficStaticIntegration extends MockIntegration {
     constructor(resource: Resource, mediaType: MediaType, response: string, enableCors?: boolean, apiKeyRequired?: boolean, headers?: Record<string, string>);
     static json<K>(resource: Resource, response: K, enableCors?: boolean, apiKeyRequired?: boolean, headers?: Record<string, string>): DigitrafficStaticIntegration;
     static createIntegrationResponse(response: string, mediaType: MediaType, headers?: Record<string, string>): IntegrationResponse;
-    static createMethodResponse(headers: Record<string, string>): {
-        statusCode: string;
-        responseParameters: Record<string, boolean>;
-    };
+    static createMethodResponse(headers: Record<string, string>): MethodResponse;
 }

package/dist/utils/api-model.d.ts

@@ -1,4 +1,4 @@
-import { type JsonSchema, JsonSchemaType, JsonSchemaVersion, type Model, type RequestValidator, type RestApi } from "aws-cdk-lib/aws-apigateway";
+import { type JsonSchema, type Model, type RequestValidator, type RestApi } from "aws-cdk-lib/aws-apigateway";
 import type { ModelWithReference } from "../aws/types/model-with-reference.js";
 type ModelReferenceUrl = `https://apigateway.amazonaws.com/restapis/${string}/models/${string}`;
 /**
@@ -42,47 +42,10 @@ export declare function createArraySchema(model: Model, api: RestApi): JsonSchem
  * Creates a JSON Schema for a GeoJSON Feature. Can be used to generate OpenAPI descriptions.
  * @param modelReference Reference to a model object
  */
-export declare function featureSchema(modelReference: string): {
-    schema: JsonSchemaVersion;
-    type: JsonSchemaType;
-    description: string;
-    required: string[];
-    properties: {
-        type: {
-            type: JsonSchemaType;
-            description: string;
-            enum: string[];
-        };
-        properties: {
-            ref: string;
-        };
-        geometry: {
-            type: JsonSchemaType;
-            description: string;
-        };
-    };
-};
+export declare function featureSchema(modelReference: string): JsonSchema;
 /**
  * Creates a JSON Schema for a GeoJSON Feature Collection. Can be used to generate OpenAPI descriptions.
  * @param modelReference Reference to a model object, in this case Features.
  */
-export declare function geojsonSchema(modelReference: string): {
-    schema: JsonSchemaVersion;
-    type: JsonSchemaType;
-    description: string;
-    required: string[];
-    properties: {
-        type: {
-            type: JsonSchemaType;
-            description: string;
-            enum: string[];
-        };
-        features: {
-            type: JsonSchemaType;
-            items: {
-                ref: string;
-            };
-        };
-    };
-};
+export declare function geojsonSchema(modelReference: string): JsonSchema;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2024.8.30-1",
+  "version": "2024.9.24-3",
   "description": "",
   "type": "module",
   "repository": {