@deployport/api-services-corelib 0.1.0

package/configurator/index.d.ts

@@ -0,0 +1,2 @@
+import { Runtime } from "@deployport/specular-runtime";
+export declare function Configure(c?: Runtime.ClientConfig): Runtime.ClientConfig;

package/configurator/index.js

@@ -0,0 +1,12 @@
+import { ConfigureSignatureV1 } from "./signer.js";
+import { Runtime } from "@deployport/specular-runtime";
+export function Configure(c) {
+    const requestConfigurators = c?.requestConfigurators ?? [];
+    requestConfigurators.push(async (sub) => {
+        console.warn("configuring request from config", sub.request);
+        await ConfigureSignatureV1(sub, c);
+    });
+    return Runtime.MergeClientConfig(c, {
+        requestConfigurators,
+    });
+}

package/configurator/index.ts

@@ -0,0 +1,13 @@
+import { Config, ConfigureSignatureV1 } from "./signer.js";
+import { Runtime } from "@deployport/specular-runtime";
+
+export function Configure(c?: Runtime.ClientConfig): Runtime.ClientConfig {
+    const requestConfigurators = c?.requestConfigurators ?? [];
+    requestConfigurators.push(async (sub) => {
+        console.warn("configuring request from config", sub.request);
+        await ConfigureSignatureV1(sub, c as Config)
+    });
+    return Runtime.MergeClientConfig(c, {
+        requestConfigurators,
+    });
+}

package/configurator/signer.d.ts

@@ -0,0 +1,22 @@
+import { Runtime } from "@deployport/specular-runtime";
+type Credentials = {
+    keyID: string;
+    secret: string;
+};
+export type Config = {
+    deployport?: {
+        region?: string;
+        accessKeyID?: string;
+        secretAccessKey?: string;
+    };
+};
+export declare function ConfigureSignatureV1(submission: Runtime.Submission, config: Config): Promise<void>;
+export declare const getSigningKeyReal: (credentials: Credentials, shortDate: string, region: string, service: string, vendor: string) => Promise<Uint8Array>;
+/**
+ * Converts a Uint8Array of binary data to a hexadecimal encoded string.
+ *
+ * @param bytes The binary data to encode
+ */
+export declare function toHex(bytes: Uint8Array): string;
+export declare const iso8601: (time: Date) => string;
+export {};

package/configurator/signer.js

@@ -0,0 +1,256 @@
+import { Sha256 } from '@aws-crypto/sha256-js';
+const VendorCode = 'dpp';
+export async function ConfigureSignatureV1(submission, config) {
+    // const { request } = submission;
+    // const { headers } = request;
+    // if (!headers["x-specular-signature"]) {
+    //     headers["x-specular-signature"] = "v1";
+    // }
+    console.log("Hello from ConfigureSignatureV1 in runtime/signer.ts!", submission);
+    const annotations = submission.operation.resource.package.annotations;
+    console.log("service annotations", annotations);
+    const ServiceSignatureV1 = annotations.find((a) => a.constructor.name === "ServiceSignatureV1");
+    if (!ServiceSignatureV1) {
+        return;
+    }
+    console.log("signing using config", config);
+    const { deployport } = config;
+    if (!deployport) {
+        console.warn("missing required deployport configuration for signing", config);
+        return;
+    }
+    const { region, accessKeyID: keyID, secretAccessKey: secret } = deployport;
+    if (!region || !keyID || !secret) {
+        console.warn("missing required configuration for signing", deployport);
+        return;
+    }
+    const { ServiceName: signingService } = ServiceSignatureV1;
+    console.log("annotations", annotations, VendorCode, signingService);
+    const { longDate, shortDate } = formatDate(new Date());
+    const signingScope = buildSigningScope(VendorCode, region, signingService, shortDate);
+    console.log("signingScope", signingScope);
+    const credentialPart = buildCredentialPart(keyID, signingScope);
+    console.log("credentialPart", credentialPart);
+    const authHeaderPrefix = vendorAlgorithm(VendorCode) + " " + credentialPart;
+    const bodyDigest = toHex(await hashSHA256(submission.request.body));
+    console.log("bodyDigest", bodyDigest);
+    const headers = submission.request.headers;
+    headers[vendorDateHeaderKey(VendorCode)] = longDate;
+    headers[vendorHeaderCanonicalNameKey(VendorCode, "Service")] = signingService;
+    headers[vendorHeaderCanonicalNameKey(VendorCode, "Resource")] = submission.operation.resource.packageUniqueName;
+    headers[vendorHeaderCanonicalNameKey(VendorCode, "Operation")] = submission.operation.name;
+    headers[vendorRegionHeaderKey(VendorCode)] = region;
+    headers[vendorHeaderCanonicalNameKey(VendorCode, "Content-Sha256")] = bodyDigest;
+    console.log("headers", headers);
+    const canonicalHeaders = getCanonicalHeaders(VendorCode, headers);
+    const credentials = {
+        keyID,
+        secret,
+    };
+    const signingKey = getSigningKey(credentials, region, shortDate, signingService, VendorCode);
+    const { request } = submission;
+    // const payloadHash = await getPayloadHash(request.body);
+    const signature = await getSignature(VendorCode, longDate, signingScope, signingKey, createCanonicalRequest(request, canonicalHeaders, bodyDigest));
+    headers["Authorization"] = [authHeaderPrefix, `SignedHeaders=${canonicalHeaders.signedHeaders}`, `Signature=${signature}`];
+    console.log("signed headers", headers);
+}
+function createCanonicalRequest(request, canonicalHeaders, payloadHash) {
+    const sortedHeaders = canonicalHeaders.names;
+    return `${request.method}
+${getCanonicalPath(request)}
+${getCanonicalQuery(request)}
+${sortedHeaders.map((name) => `${name}:${canonicalHeaders.clean[name]}`).join("\n")}
+
+${canonicalHeaders.signedHeaders}
+${payloadHash}`;
+}
+function getCanonicalQuery({ path }) {
+    return ""; // TODO: hardcoded, we don't use query strings
+}
+function getCanonicalPath({ path }) {
+    console.log("getCanonicalPath path", path);
+    return path;
+    // if (this.uriEscapePath) {
+    // Non-S3 services, we normalize the path and then double URI encode it.
+    // Ref: "Remove Dot Segments" https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+    const normalizedPathSegments = [];
+    for (const pathSegment of path.split("/")) {
+        if (pathSegment?.length === 0)
+            continue;
+        if (pathSegment === ".")
+            continue;
+        if (pathSegment === "..") {
+            normalizedPathSegments.pop();
+        }
+        else {
+            normalizedPathSegments.push(pathSegment);
+        }
+        // }
+        // Joining by single slashes to remove consecutive slashes.
+        const normalizedPath = `${path?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path?.endsWith("/") ? "/" : ""}`;
+        const doubleEncoded = encodeURIComponent(normalizedPath);
+        return doubleEncoded.replace(/%2F/g, "/");
+    }
+    // For S3, we shouldn't normalize the path. For example, object name
+    // my-object//example//photo.user should not be normalized to
+    // my-object/example/photo.user
+    console.log("getCanonicalPath path (curated)", path);
+    return path;
+}
+// /**
+//  * @private
+//  */
+// export const getPayloadHash = async (
+//     body: string,
+// ): Promise<string> => {
+//     const hashCtor = new Sha256();
+//     // new Sha256().update(toUint8Array(body));
+//     new Sha256().update(body);
+//     return toHex(await hashCtor.digest());
+// };
+async function getSignature(vendor, longDate, credentialScope, keyPromise, canonicalRequest) {
+    const stringToSign = await createStringToSign(vendor, longDate, credentialScope, canonicalRequest);
+    console.log("stringToSign", stringToSign);
+    const hash = new Sha256(await keyPromise);
+    hash.update(stringToSign);
+    return toHex(await hash.digest());
+}
+async function createStringToSign(vendor, longDate, credentialScope, canonicalRequest) {
+    console.log('canonicalRequest', canonicalRequest);
+    const hash = new Sha256();
+    hash.update(canonicalRequest);
+    const hashedRequest = await hash.digest();
+    return `${vendorAlgorithm(vendor)}
+${longDate}
+${credentialScope}
+${toHex(hashedRequest)}`;
+}
+const toUtf8 = (input) => new TextDecoder("utf-8").decode(input);
+// export const toUint8Array = (data: string | ArrayBuffer | ArrayBufferView): Uint8Array => {
+//     // if (typeof data === "string") {
+//     //     return fromUtf8(data);
+//     // }
+//     // if (ArrayBuffer.isView(data)) {
+//     //     return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+//     // }
+//     // return new Uint8Array(data);
+//     return new Uint8Array(data);
+// };
+async function getSigningKey(credentials, region, shortDate, service, vendor) {
+    return getSigningKeyReal(credentials, shortDate, region, service, vendor);
+}
+function vendorKeyType(vendor) {
+    return vendor + "1_request";
+}
+export const getSigningKeyReal = async (credentials, shortDate, region, service, vendor) => {
+    let key = `${vendor}1${credentials.secret}`;
+    for (const signable of [shortDate, region, service, vendorKeyType(vendor)]) {
+        key = await hmac(key, signable);
+    }
+    return key;
+};
+// type signingData = string | Uint8Array;
+const hmac = (secret, data) => {
+    const hash = new Sha256(secret);
+    hash.update(data);
+    return hash.digest();
+};
+function getCanonicalHeaders(vendorCode, headers) {
+    const validHeaderNames = [
+        "Host",
+        vendorDateHeaderKey(vendorCode),
+        vendorHeaderCanonicalNameKey(vendorCode, "Service"),
+        vendorHeaderCanonicalNameKey(vendorCode, "Resource"),
+        vendorHeaderCanonicalNameKey(vendorCode, "Operation"),
+        vendorHeaderCanonicalNameKey(vendorCode, "Content-Sha256"),
+        vendorHeaderCanonicalNameKey(vendorCode, "Region"),
+    ];
+    const cleaned = {};
+    for (const key in headers) {
+        if (!validHeaderNames.includes(key)) {
+            continue;
+        }
+        const val = headers[key];
+        if (Array.isArray(val)) {
+            cleaned[key] = val.map(v => v.trim());
+        }
+        else {
+            cleaned[key] = val.trim();
+        }
+    }
+    const names = Object.keys(cleaned).sort();
+    return {
+        names,
+        signedHeaders: names.map(n => n.toLowerCase()).join(";"),
+        clean: cleaned,
+    };
+}
+const SHORT_TO_HEX = {};
+for (let i = 0; i < 256; i++) {
+    let encodedByte = i.toString(16).toLowerCase();
+    if (encodedByte.length === 1) {
+        encodedByte = `0${encodedByte}`;
+    }
+    SHORT_TO_HEX[i] = encodedByte;
+}
+/**
+ * Converts a Uint8Array of binary data to a hexadecimal encoded string.
+ *
+ * @param bytes The binary data to encode
+ */
+export function toHex(bytes) {
+    let out = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
+        out += SHORT_TO_HEX[bytes[i]];
+    }
+    return out;
+}
+// convert hashSHA256 to ts
+async function hashSHA256(dataStr) {
+    const data = new TextEncoder().encode(dataStr);
+    const hash = new Sha256();
+    hash.update(data);
+    return await hash.digest();
+}
+const credentialPartPrefix = "Credential=";
+function buildCredentialPart(keyID, signingScope) {
+    return `${credentialPartPrefix}${keyID}/${signingScope}`;
+}
+function buildSigningScope(vendorCode, region, service, shortDate) {
+    return [
+        shortDate,
+        region,
+        service,
+        vendorRequestCode(vendorCode),
+    ].join("/");
+}
+function vendorRequestCode(vendorCode) {
+    return vendorCode + "1_request";
+}
+function vendorAlgorithm(vendorCode) {
+    return vendorCode.toUpperCase() + "1-HMAC-SHA256";
+}
+// function formatShortTime(dt: Date): string {
+//     return dt.toISOString().replace(/[-:]/g, "").slice(0, 15);
+// }
+export const iso8601 = (time) => time.toISOString()
+    .replace(/\.\d{3}Z$/, "Z");
+const formatDate = (now) => {
+    const longDate = iso8601(now).replace(/[\-:]/g, "");
+    return {
+        longDate,
+        shortDate: longDate.slice(0, 8),
+    };
+};
+function vendorDateHeaderKey(vendorCode) {
+    return vendorHeaderCanonicalNameKey(vendorCode, "Date");
+}
+function vendorRegionHeaderKey(vendorCode) {
+    return vendorHeaderCanonicalNameKey(vendorCode, "Region");
+}
+function vendorHeaderCanonicalNameKey(vendorCode, header) {
+    return httpHeaderStandardName("x-" + vendorCode + "-" + header.toLowerCase());
+}
+function httpHeaderStandardName(header) {
+    return header.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("-");
+}

package/configurator/signer.ts

@@ -0,0 +1,361 @@
+import { Sha256 } from '@aws-crypto/sha256-js';
+import { Runtime } from "@deployport/specular-runtime";
+import { SourceData } from "@aws-sdk/types";
+
+type Credentials = {
+    keyID: string;
+    secret: string;
+}
+
+export type Config = {
+    deployport?: {
+        region?: string;
+        accessKeyID?: string;
+        secretAccessKey?: string;
+    }
+}
+
+const VendorCode = 'dpp';
+
+export async function ConfigureSignatureV1(submission: Runtime.Submission, config: Config): Promise<void> {
+
+    // const { request } = submission;
+    // const { headers } = request;
+    // if (!headers["x-specular-signature"]) {
+    //     headers["x-specular-signature"] = "v1";
+    // }
+    console.log("Hello from ConfigureSignatureV1 in runtime/signer.ts!", submission)
+    const annotations = submission.operation.resource.package.annotations;
+    console.log("service annotations", annotations);
+    const ServiceSignatureV1 = annotations.find((a) => a.constructor.name === "ServiceSignatureV1");
+    if (!ServiceSignatureV1) {
+        return;
+    }
+    console.log("signing using config", config)
+    const { deployport } = config;
+    if (!deployport) {
+        console.warn("missing required deployport configuration for signing", config);
+        return;
+    }
+    const { region, accessKeyID: keyID, secretAccessKey: secret } = deployport;
+    if (!region || !keyID || !secret) {
+        console.warn("missing required configuration for signing", deployport);
+        return;
+    }
+    const { ServiceName: signingService } = ServiceSignatureV1;
+    console.log("annotations", annotations, VendorCode, signingService);
+    const { longDate, shortDate } = formatDate(new Date());
+    const signingScope = buildSigningScope(VendorCode, region, signingService, shortDate);
+    console.log("signingScope", signingScope);
+
+    const credentialPart = buildCredentialPart(keyID, signingScope);
+    console.log("credentialPart", credentialPart);
+
+    const authHeaderPrefix = vendorAlgorithm(VendorCode) + " " + credentialPart
+
+    const bodyDigest = toHex(await hashSHA256(submission.request.body));
+    console.log("bodyDigest", bodyDigest);
+    const headers = submission.request.headers;
+    headers[vendorDateHeaderKey(VendorCode)] = longDate;
+    headers[vendorHeaderCanonicalNameKey(VendorCode, "Service")] = signingService;
+    headers[vendorHeaderCanonicalNameKey(VendorCode, "Resource")] = submission.operation.resource.packageUniqueName;
+    headers[vendorHeaderCanonicalNameKey(VendorCode, "Operation")] = submission.operation.name;
+    headers[vendorRegionHeaderKey(VendorCode)] = region;
+    headers[vendorHeaderCanonicalNameKey(VendorCode, "Content-Sha256")] = bodyDigest;
+    console.log("headers", headers);
+    const canonicalHeaders = getCanonicalHeaders(VendorCode, headers);
+
+    const credentials: Credentials = {
+        keyID,
+        secret,
+    }
+
+    const signingKey = getSigningKey(credentials, region, shortDate, signingService, VendorCode);
+
+    const { request } = submission;
+
+    // const payloadHash = await getPayloadHash(request.body);
+    const signature = await getSignature(
+        VendorCode,
+        longDate,
+        signingScope,
+        signingKey,
+        createCanonicalRequest(request, canonicalHeaders, bodyDigest)
+    );
+
+    headers["Authorization"] = [authHeaderPrefix, `SignedHeaders=${canonicalHeaders.signedHeaders}`, `Signature=${signature}`] as any;
+    console.log("signed headers", headers);
+}
+
+function createCanonicalRequest(request: Runtime.HTTPRequest, canonicalHeaders: CanonicalHeaders, payloadHash: string): string {
+    const sortedHeaders = canonicalHeaders.names;
+    return `${request.method}
+${getCanonicalPath(request)}
+${getCanonicalQuery(request)}
+${sortedHeaders.map((name) => `${name}:${canonicalHeaders.clean[name]}`).join("\n")}
+
+${canonicalHeaders.signedHeaders}
+${payloadHash}`;
+}
+
+function getCanonicalQuery({ path }: Runtime.HTTPRequest): string {
+    return ""; // TODO: hardcoded, we don't use query strings
+}
+
+function getCanonicalPath({ path }: Runtime.HTTPRequest): string {
+    console.log("getCanonicalPath path", path);
+    return path;
+    // if (this.uriEscapePath) {
+    // Non-S3 services, we normalize the path and then double URI encode it.
+    // Ref: "Remove Dot Segments" https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+    const normalizedPathSegments: string[] = [];
+    for (const pathSegment of path.split("/")) {
+        if (pathSegment?.length === 0) continue;
+        if (pathSegment === ".") continue;
+        if (pathSegment === "..") {
+            normalizedPathSegments.pop();
+        } else {
+            normalizedPathSegments.push(pathSegment);
+        }
+        // }
+        // Joining by single slashes to remove consecutive slashes.
+        const normalizedPath = `${path?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path?.endsWith("/") ? "/" : ""
+            }`;
+
+        const doubleEncoded = encodeURIComponent(normalizedPath);
+        return doubleEncoded.replace(/%2F/g, "/");
+    }
+
+    // For S3, we shouldn't normalize the path. For example, object name
+    // my-object//example//photo.user should not be normalized to
+    // my-object/example/photo.user
+
+    console.log("getCanonicalPath path (curated)", path);
+    return path;
+}
+
+
+// /**
+//  * @private
+//  */
+// export const getPayloadHash = async (
+//     body: string,
+// ): Promise<string> => {
+//     const hashCtor = new Sha256();
+//     // new Sha256().update(toUint8Array(body));
+//     new Sha256().update(body);
+//     return toHex(await hashCtor.digest());
+// };
+
+async function getSignature(
+    vendor: string,
+    longDate: string,
+    credentialScope: string,
+    keyPromise: Promise<Uint8Array>,
+    canonicalRequest: string
+): Promise<string> {
+    const stringToSign = await createStringToSign(vendor, longDate, credentialScope, canonicalRequest);
+    console.log("stringToSign", stringToSign);
+
+    const hash = new Sha256(await keyPromise);
+    hash.update(stringToSign);
+    return toHex(await hash.digest());
+}
+
+async function createStringToSign(
+    vendor: string,
+    longDate: string,
+    credentialScope: string,
+    canonicalRequest: string
+): Promise<string> {
+    console.log('canonicalRequest', canonicalRequest);
+    const hash = new Sha256();
+    hash.update(canonicalRequest);
+    const hashedRequest = await hash.digest();
+
+    return `${vendorAlgorithm(vendor)}
+${longDate}
+${credentialScope}
+${toHex(hashedRequest)}`;
+}
+
+const toUtf8 = (input: Uint8Array): string => new TextDecoder("utf-8").decode(input);
+
+// export const toUint8Array = (data: string | ArrayBuffer | ArrayBufferView): Uint8Array => {
+//     // if (typeof data === "string") {
+//     //     return fromUtf8(data);
+//     // }
+
+//     // if (ArrayBuffer.isView(data)) {
+//     //     return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+//     // }
+
+//     // return new Uint8Array(data);
+//     return new Uint8Array(data);
+// };
+
+async function getSigningKey(
+    credentials: Credentials,
+    region: string,
+    shortDate: string,
+    service: string,
+    vendor: string,
+): Promise<Uint8Array> {
+    return getSigningKeyReal(credentials, shortDate, region, service, vendor);
+}
+
+function vendorKeyType(vendor: string): string {
+    return vendor + "1_request";
+}
+
+export const getSigningKeyReal = async (
+    credentials: Credentials,
+    shortDate: string,
+    region: string,
+    service: string,
+    vendor: string,
+): Promise<Uint8Array> => {
+    let key: SourceData = `${vendor}1${credentials.secret}`;
+    for (const signable of [shortDate, region, service, vendorKeyType(vendor)]) {
+        key = await hmac(key, signable);
+    }
+    return key as Uint8Array;
+};
+
+// type signingData = string | Uint8Array;
+
+const hmac = (
+    secret: SourceData,
+    data: SourceData
+): Promise<Uint8Array> => {
+    const hash = new Sha256(secret);
+    hash.update(data);
+    return hash.digest();
+};
+
+
+type CanonicalHeaders = {
+    /**
+     * ordered list of header names
+     */
+    names: string[]
+    clean: Runtime.HTTPHeaders
+    signedHeaders: string
+}
+
+function getCanonicalHeaders(vendorCode: string, headers: Runtime.HTTPHeaders): CanonicalHeaders {
+    const validHeaderNames = [
+        "Host",
+        vendorDateHeaderKey(vendorCode),
+        vendorHeaderCanonicalNameKey(vendorCode, "Service"),
+        vendorHeaderCanonicalNameKey(vendorCode, "Resource"),
+        vendorHeaderCanonicalNameKey(vendorCode, "Operation"),
+        vendorHeaderCanonicalNameKey(vendorCode, "Content-Sha256"),
+        vendorHeaderCanonicalNameKey(vendorCode, "Region"),
+    ];
+    const cleaned: Runtime.HTTPHeaders = {};
+    for (const key in headers) {
+        if (!validHeaderNames.includes(key)) {
+            continue;
+        }
+        const val = headers[key];
+        if (Array.isArray(val)) {
+            cleaned[key] = val.map(v => v.trim());
+        } else {
+            cleaned[key] = val.trim();
+        }
+    }
+    const names = Object.keys(cleaned).sort();
+    return {
+        names,
+        signedHeaders: names.map(n => n.toLowerCase()).join(";"),
+        clean: cleaned,
+    };
+}
+
+
+const SHORT_TO_HEX: { [key: number]: string } = {};
+for (let i = 0; i < 256; i++) {
+    let encodedByte = i.toString(16).toLowerCase();
+    if (encodedByte.length === 1) {
+        encodedByte = `0${encodedByte}`;
+    }
+
+    SHORT_TO_HEX[i] = encodedByte;
+}
+/**
+ * Converts a Uint8Array of binary data to a hexadecimal encoded string.
+ *
+ * @param bytes The binary data to encode
+ */
+export function toHex(bytes: Uint8Array): string {
+    let out = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
+        out += SHORT_TO_HEX[bytes[i]];
+    }
+
+    return out;
+}
+
+// convert hashSHA256 to ts
+async function hashSHA256(dataStr: string): Promise<Uint8Array> {
+    const data = new TextEncoder().encode(dataStr);
+    const hash = new Sha256();
+    hash.update(data);
+    return await hash.digest();
+}
+
+const credentialPartPrefix = "Credential=";
+
+function buildCredentialPart(keyID: string, signingScope: string): string {
+    return `${credentialPartPrefix}${keyID}/${signingScope}`;
+}
+
+function buildSigningScope(vendorCode: string, region: string, service: string, shortDate: string): string {
+    return [
+        shortDate,
+        region,
+        service,
+        vendorRequestCode(vendorCode),
+    ].join("/");
+}
+
+function vendorRequestCode(vendorCode: string): string {
+    return vendorCode + "1_request";
+}
+
+function vendorAlgorithm(vendorCode: string): string {
+    return vendorCode.toUpperCase() + "1-HMAC-SHA256";
+}
+
+// function formatShortTime(dt: Date): string {
+//     return dt.toISOString().replace(/[-:]/g, "").slice(0, 15);
+// }
+
+export const iso8601 = (time: Date): string =>
+    time.toISOString()
+        .replace(/\.\d{3}Z$/, "Z");
+
+const formatDate = (now: Date): { longDate: string; shortDate: string } => {
+    const longDate = iso8601(now).replace(/[\-:]/g, "");
+    return {
+        longDate,
+        shortDate: longDate.slice(0, 8),
+    };
+};
+
+function vendorDateHeaderKey(vendorCode: string): string {
+    return vendorHeaderCanonicalNameKey(vendorCode, "Date");
+}
+
+function vendorRegionHeaderKey(vendorCode: string): string {
+    return vendorHeaderCanonicalNameKey(vendorCode, "Region");
+}
+
+function vendorHeaderCanonicalNameKey(vendorCode: string, header: string): string {
+    return httpHeaderStandardName("x-" + vendorCode + "-" + header.toLowerCase());
+}
+
+function httpHeaderStandardName(header: string): string {
+    return header.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("-");
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "@deployport/api-services-corelib",
+    "version": "0.1.0",
+    "description": "",
+    "main": "./specular.js",
+    "types": "./specular.d.ts",
+    "author": "bithavoc",
+    "scripts": {
+        "prepublishOnly": "npm run build-configurator",
+        "build-configurator": "tsc configurator/index.ts --declaration --module nodenext",
+        "clean": "rm -rf node_modules && rm -f **/*.js **/*.d.ts"
+    },
+    "type": "module",
+    "license": "MIT",
+    "dependencies": {
+        "@aws-crypto/sha256-js": "^5.2.0",
+        "@aws-sdk/types": "^3.515.0",
+        "@deployport/specular-runtime": "^0.1.5"
+    },
+    "devDependencies": {
+        "@tsconfig/node18": "^18.2.2",
+        "@types/node": "^20.8.3"
+    }
+}

package/specular.d.ts

@@ -0,0 +1,23 @@
+import { Runtime, Metadata } from '@deployport/specular-runtime';
+export declare class SignedOperationV1 {
+}
+export declare class ServiceSignatureV1 {
+    ServiceName: string;
+}
+export declare const AccessDeniedProblemMeta: Metadata.Struct;
+export interface AccessDeniedProblemProperties {
+    message: string;
+}
+export interface AccessDeniedProblem extends AccessDeniedProblemProperties, Runtime.StructInterface {
+}
+export declare class AccessDeniedProblem extends Error {
+}
+export declare const ForbiddenProblemMeta: Metadata.Struct;
+export interface ForbiddenProblemProperties {
+    message: string;
+}
+export interface ForbiddenProblem extends ForbiddenProblemProperties, Runtime.StructInterface {
+}
+export declare class ForbiddenProblem extends Error {
+}
+export declare function SpecularPackage(): Metadata.Package;

package/specular.js

@@ -0,0 +1,36 @@
+// JS gen package
+import { Metadata, } from '@deployport/specular-runtime';
+// SignedOperationV1 entity
+// Marks an operation with digital signature authentication for id4ntity verification
+export class SignedOperationV1 {
+}
+// ServiceSignatureV1 entity
+export class ServiceSignatureV1 {
+    ServiceName;
+}
+const _pkg = new Metadata.Package('Deployport/CoreLib');
+export const AccessDeniedProblemMeta = new Metadata.Struct(_pkg, "AccessDeniedProblem");
+new Metadata.Property(AccessDeniedProblemMeta, "message", {
+    NonNullable: true,
+    SubType: "builtin",
+    Builtin: "string"
+});
+;
+;
+export class AccessDeniedProblem extends Error {
+}
+AccessDeniedProblemMeta.problemInstantiate = (msg) => new AccessDeniedProblem(msg);
+export const ForbiddenProblemMeta = new Metadata.Struct(_pkg, "ForbiddenProblem");
+new Metadata.Property(ForbiddenProblemMeta, "message", {
+    NonNullable: true,
+    SubType: "builtin",
+    Builtin: "string"
+});
+;
+;
+export class ForbiddenProblem extends Error {
+}
+ForbiddenProblemMeta.problemInstantiate = (msg) => new ForbiddenProblem(msg);
+export function SpecularPackage() {
+    return _pkg;
+}

package/specular.ts

@@ -0,0 +1,70 @@
+// JS gen package
+import {
+    Runtime,
+    Metadata,
+} from '@deployport/specular-runtime';
+
+// SignedOperationV1 entity
+// Marks an operation with digital signature authentication for id4ntity verification
+export class SignedOperationV1 {
+}
+
+// ServiceSignatureV1 entity
+export class ServiceSignatureV1 {
+    public ServiceName: string;
+}
+
+const _pkg = new Metadata.Package(
+    'Deployport/CoreLib',
+);
+
+export const AccessDeniedProblemMeta = new Metadata.Struct(
+    _pkg, 
+    "AccessDeniedProblem", 
+);
+new Metadata.Property(AccessDeniedProblemMeta, "message", {
+NonNullable: true,
+SubType: "builtin",
+Builtin: "string"
+});
+// AccessDeniedProblem entity
+export interface AccessDeniedProblemProperties
+ {
+    // /**
+    // * Returns "Deployport/CoreLib:AccessDeniedProblem"
+    // */
+    // fqtn: "Deployport/CoreLib:AccessDeniedProblem";
+    message : string;
+};
+export interface AccessDeniedProblem extends AccessDeniedProblemProperties, Runtime.StructInterface{};
+export class AccessDeniedProblem 
+    extends Error
+{}
+AccessDeniedProblemMeta.problemInstantiate = (msg: string) => new AccessDeniedProblem(msg);
+export const ForbiddenProblemMeta = new Metadata.Struct(
+    _pkg, 
+    "ForbiddenProblem", 
+);
+new Metadata.Property(ForbiddenProblemMeta, "message", {
+NonNullable: true,
+SubType: "builtin",
+Builtin: "string"
+});
+// ForbiddenProblem entity
+export interface ForbiddenProblemProperties
+ {
+    // /**
+    // * Returns "Deployport/CoreLib:ForbiddenProblem"
+    // */
+    // fqtn: "Deployport/CoreLib:ForbiddenProblem";
+    message : string;
+};
+export interface ForbiddenProblem extends ForbiddenProblemProperties, Runtime.StructInterface{};
+export class ForbiddenProblem 
+    extends Error
+{}
+ForbiddenProblemMeta.problemInstantiate = (msg: string) => new ForbiddenProblem(msg);
+
+export function SpecularPackage() {
+    return _pkg;
+}

package/specular.yaml

@@ -0,0 +1,6 @@
+packages:
+  - origin: "file://./../api-services-core-lib//package.specular"
+    generate:
+      - language: js
+        client:
+          output: .