@deployport/api-services-corelib 0.1.4 → 0.3.0

package/configurator/signer.ts

@@ -1,61 +1,60 @@
 import { Sha256 } from '@aws-crypto/sha256-js';
 import { Runtime } from "@deployport/specular-runtime";
 import { SourceData } from "@aws-sdk/types";
-import { ServiceSignatureV1 } from '../specular.js';
+import { ServiceSignatureV1, SignedOperationV1 } from '../specular.js';
+import type { Config } from "./config.js";
 
 type Credentials = {
     keyID: string;
     secret: string;
 }
 
-export type Config = {
-    deployport?: {
-        region?: string;
-        accessKeyID?: string;
-        secretAccessKey?: string;
+const VendorCode = 'dpp';
+
+/**
+ * Replaces the `<region>` placeholder in the request URL and Host header with
+ * the given region. Mirrors Go's `ReplaceRegionInRequest`. Runs for every
+ * request that has a resolved region, whether or not the request is signed.
+ */
+export function replaceRegionInRequest(request: Runtime.HTTPRequest, region: string): void {
+    if (request.url) {
+        request.url = request.url.replaceAll("<region>", region);
+    }
+    const host = request.headers["Host"];
+    if (typeof host === "string") {
+        request.headers["Host"] = host.replaceAll("<region>", region);
     }
 }
 
-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)
+    // sign only operations that opted in via SignedOperationV1
+    const signedOperationV1 = submission.operation.annotations.find((a) => a instanceof SignedOperationV1);
+    if (!signedOperationV1) {
+        return;
+    }
     const annotations = submission.operation.resource.package.annotations;
-    console.log("service annotations", annotations);
     const serviceSignatureV1 = annotations.find((a) => a instanceof 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);
+        // Incomplete credentials/region: leave the request unsigned.
         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;
@@ -63,7 +62,6 @@ export async function ConfigureSignatureV1(submission: Runtime.Submission, confi
     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 = {
@@ -85,7 +83,6 @@ export async function ConfigureSignatureV1(submission: Runtime.Submission, confi
     );
 
     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 {
@@ -104,7 +101,6 @@ function getCanonicalQuery({ path }: Runtime.HTTPRequest): string {
 }
 
 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.
@@ -131,7 +127,6 @@ function getCanonicalPath({ path }: Runtime.HTTPRequest): string {
     // my-object//example//photo.user should not be normalized to
     // my-object/example/photo.user
 
-    console.log("getCanonicalPath path (curated)", path);
     return path;
 }
 
@@ -156,7 +151,6 @@ async function getSignature(
     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);
@@ -169,7 +163,6 @@ async function createStringToSign(
     credentialScope: string,
     canonicalRequest: string
 ): Promise<string> {
-    console.log('canonicalRequest', canonicalRequest);
     const hash = new Sha256();
     hash.update(canonicalRequest);
     const hashedRequest = await hash.digest();

package/package.json

@@ -1,15 +1,41 @@
 {
     "name": "@deployport/api-services-corelib",
-    "version": "0.1.4",
+    "version": "0.3.0",
     "description": "",
     "main": "./specular.js",
     "types": "./specular.d.ts",
+    "exports": {
+        ".": {
+            "types": "./specular.d.ts",
+            "default": "./specular.js"
+        },
+        "./configurator": {
+            "types": "./configurator/index.d.ts",
+            "default": "./configurator/index.js"
+        },
+        "./configurator/node": {
+            "types": "./configurator/loader.node.d.ts",
+            "default": "./configurator/loader.node.js"
+        }
+    },
+    "imports": {
+        "#config-loader": {
+            "browser": "./configurator/loader.browser.js",
+            "node": "./configurator/loader.node.js",
+            "default": "./configurator/loader.browser.js"
+        }
+    },
     "author": "bithavoc",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/deployport/api-services-corelib-js.git"
+    },
     "scripts": {
         "prepublishOnly": "npm run build-configurator",
         "generate": "specular-standalone-compiler generate",
-        "build-configurator": "tsc configurator/index.ts --declaration --module nodenext",
+        "build-configurator": "tsc",
         "build": "npm run build-configurator",
+        "test": "vitest run",
         "clean": "rm -rf node_modules && rm -f **/*.js **/*.d.ts"
     },
     "type": "module",
@@ -17,10 +43,13 @@
     "dependencies": {
         "@aws-crypto/sha256-js": "^5.2.0",
         "@aws-sdk/types": "^3.515.0",
-        "@deployport/specular-runtime": "^0.1.11"
+        "@deployport/specular-runtime": "^0.2.1",
+        "yaml": "^2.6.1"
     },
     "devDependencies": {
-        "@tsconfig/node18": "^18.2.2",
-        "@types/node": "^20.8.3"
+        "@tsconfig/node24": "^24.0.4",
+        "@types/node": "^24.13.2",
+        "typescript": "^6.0.3",
+        "vitest": "^3.0.0"
     }
-}
+}

package/specular.d.ts

@@ -1,23 +1,114 @@
 import { Runtime, Metadata } from '@deployport/specular-runtime';
+/** Marks an operation with digital signature authentication for id4ntity verification
+*/
 export declare class SignedOperationV1 {
 }
+/** entity ServiceSignatureV1
+*/
 export declare class ServiceSignatureV1 {
+    /** serviceName parameter
+*/
     ServiceName: string;
 }
+/** Struct metadata
+*/
 export declare const AccessDeniedProblemMeta: Metadata.Struct;
+/** struct AccessDeniedProblem
+*/
 export interface AccessDeniedProblemProperties {
+    /** message property
+*/
     message: string;
 }
-export declare class AccessDeniedProblem extends Error implements AccessDeniedProblemProperties, Runtime.StructInterface {
-    message: string;
+/** struct AccessDeniedProblem
+*/
+export declare class AccessDeniedProblem extends Runtime.RpcError implements AccessDeniedProblemProperties, Runtime.StructInterface {
     get __structPath(): Metadata.StructPath;
 }
+/** Struct metadata
+*/
 export declare const ForbiddenProblemMeta: Metadata.Struct;
+/** struct ForbiddenProblem
+*/
 export interface ForbiddenProblemProperties {
+    /** message property
+*/
+    message: string;
+}
+/** struct ForbiddenProblem
+*/
+export declare class ForbiddenProblem extends Runtime.RpcError implements ForbiddenProblemProperties, Runtime.StructInterface {
+    get __structPath(): Metadata.StructPath;
+}
+/** Struct metadata
+*/
+export declare const ProblemActionMeta: Metadata.Struct;
+/** A localized call-to-action surfaced alongside a problem. Title and URL
+* are already resolved to a specific locale; clients render them as-is.
+*/
+export interface ProblemActionProperties {
+    /** Optional stable identifier. Clients can key on it to apply custom
+* presentation (icon, ordering) per well-known action.
+*/
+    id: string;
+    /** BCP 47 tag of the locale the title and url were resolved to. May
+* differ from the caller's requested locale when a fallback was used.
+*/
+    locale: string | null;
+    /** title property
+*/
+    title: string;
+    /** url property
+*/
+    url: string | null;
+}
+/** A localized call-to-action surfaced alongside a problem. Title and URL
+* are already resolved to a specific locale; clients render them as-is.
+*/
+export interface ProblemAction extends ProblemActionProperties, Runtime.StructInterface {
+}
+/** Struct metadata
+*/
+export declare const ThrottledProblemMeta: Metadata.Struct;
+/** Raised when the caller is being throttled and should retry later.
+*/
+export interface ThrottledProblemProperties {
+    /** Optional calls-to-action to help the caller (e.g. support, upgrade,
+* docs links), ordered most-specific first. Empty when none apply.
+*/
+    actions: (ProblemActionProperties)[];
+    /** message property
+*/
     message: string;
+    /** Milliseconds the caller should wait before retrying.
+*/
+    retryAfterMs: number | null;
 }
-export declare class ForbiddenProblem extends Error implements ForbiddenProblemProperties, Runtime.StructInterface {
+/** Raised when the caller is being throttled and should retry later.
+*/
+export declare class ThrottledProblem extends Runtime.RpcError implements ThrottledProblemProperties, Runtime.StructInterface {
+    actions: (ProblemActionProperties)[];
+    retryAfterMs: number | null;
+    get __structPath(): Metadata.StructPath;
+}
+/** Struct metadata
+*/
+export declare const QuotaExceededProblemMeta: Metadata.Struct;
+/** Raised when a resource quota has been exceeded.
+*/
+export interface QuotaExceededProblemProperties {
+    /** Optional calls-to-action to help the caller (e.g. request an increase,
+* upgrade, docs links), ordered most-specific first. Empty when none apply.
+*/
+    actions: (ProblemActionProperties)[];
+    /** message property
+*/
     message: string;
+}
+/** Raised when a resource quota has been exceeded.
+*/
+export declare class QuotaExceededProblem extends Runtime.RpcError implements QuotaExceededProblemProperties, Runtime.StructInterface {
+    actions: (ProblemActionProperties)[];
     get __structPath(): Metadata.StructPath;
 }
 export declare function SpecularPackage(): Metadata.Package;

package/specular.js

@@ -1,40 +1,129 @@
-// JS gen package
-import { Metadata, } from '@deployport/specular-runtime';
-// SignedOperationV1 entity
-// Marks an operation with digital signature authentication for id4ntity verification
+import { Runtime, Metadata, } from '@deployport/specular-runtime';
+/** Marks an operation with digital signature authentication for id4ntity verification
+*/
 export class SignedOperationV1 {
 }
-// ServiceSignatureV1 entity
+/** entity ServiceSignatureV1
+*/
 export class ServiceSignatureV1 {
+    /** serviceName parameter
+*/
     ServiceName = '';
 }
 const _pkg = new Metadata.Package("deployport", "corelib");
+/** Struct metadata
+*/
 export const AccessDeniedProblemMeta = new Metadata.Struct(_pkg, "AccessDeniedProblem");
 new Metadata.Property(AccessDeniedProblemMeta, "message", {
     NonNullable: true,
     SubType: "builtin",
     Builtin: "string"
 });
-export class AccessDeniedProblem extends Error {
-    message = '';
+/** struct AccessDeniedProblem
+*/
+export class AccessDeniedProblem extends Runtime.RpcError {
     get __structPath() {
         return AccessDeniedProblemMeta.path;
     }
 }
 AccessDeniedProblemMeta.problemInstantiate = (msg) => new AccessDeniedProblem(msg);
+/** Struct metadata
+*/
 export const ForbiddenProblemMeta = new Metadata.Struct(_pkg, "ForbiddenProblem");
 new Metadata.Property(ForbiddenProblemMeta, "message", {
     NonNullable: true,
     SubType: "builtin",
     Builtin: "string"
 });
-export class ForbiddenProblem extends Error {
-    message = '';
+/** struct ForbiddenProblem
+*/
+export class ForbiddenProblem extends Runtime.RpcError {
     get __structPath() {
         return ForbiddenProblemMeta.path;
     }
 }
 ForbiddenProblemMeta.problemInstantiate = (msg) => new ForbiddenProblem(msg);
+/** Struct metadata
+*/
+export const ProblemActionMeta = new Metadata.Struct(_pkg, "ProblemAction");
+new Metadata.Property(ProblemActionMeta, "id", {
+    NonNullable: true,
+    SubType: "builtin",
+    Builtin: "string"
+});
+new Metadata.Property(ProblemActionMeta, "locale", {
+    NonNullable: false,
+    SubType: "builtin",
+    Builtin: "string"
+});
+new Metadata.Property(ProblemActionMeta, "title", {
+    NonNullable: true,
+    SubType: "builtin",
+    Builtin: "string"
+});
+new Metadata.Property(ProblemActionMeta, "url", {
+    NonNullable: false,
+    SubType: "builtin",
+    Builtin: "string"
+});
+/** Struct metadata
+*/
+export const ThrottledProblemMeta = new Metadata.Struct(_pkg, "ThrottledProblem");
+new Metadata.Property(ThrottledProblemMeta, "actions", {
+    NonNullable: true,
+    SubType: "array",
+    Item: {
+        NonNullable: true,
+        SubType: "userDefined",
+        Type: SpecularPackage().requireTypeByName("ProblemAction")
+    }
+});
+new Metadata.Property(ThrottledProblemMeta, "message", {
+    NonNullable: true,
+    SubType: "builtin",
+    Builtin: "string"
+});
+new Metadata.Property(ThrottledProblemMeta, "retryAfterMs", {
+    NonNullable: false,
+    SubType: "builtin",
+    Builtin: "int64"
+});
+/** Raised when the caller is being throttled and should retry later.
+*/
+export class ThrottledProblem extends Runtime.RpcError {
+    actions = [];
+    retryAfterMs = null;
+    get __structPath() {
+        return ThrottledProblemMeta.path;
+    }
+}
+ThrottledProblemMeta.problemInstantiate = (msg) => new ThrottledProblem(msg);
+/** Struct metadata
+*/
+export const QuotaExceededProblemMeta = new Metadata.Struct(_pkg, "QuotaExceededProblem");
+new Metadata.Property(QuotaExceededProblemMeta, "actions", {
+    NonNullable: true,
+    SubType: "array",
+    Item: {
+        NonNullable: true,
+        SubType: "userDefined",
+        Type: SpecularPackage().requireTypeByName("ProblemAction")
+    }
+});
+new Metadata.Property(QuotaExceededProblemMeta, "message", {
+    NonNullable: true,
+    SubType: "builtin",
+    Builtin: "string"
+});
+/** Raised when a resource quota has been exceeded.
+*/
+export class QuotaExceededProblem extends Runtime.RpcError {
+    actions = [];
+    get __structPath() {
+        return QuotaExceededProblemMeta.path;
+    }
+}
+QuotaExceededProblemMeta.problemInstantiate = (msg) => new QuotaExceededProblem(msg);
 export function SpecularPackage() {
     return _pkg;
 }