@apifuse/provider-sdk 2.2.0-beta.3 → 2.2.0-beta.31

package/src/schema.ts

@@ -1,13 +1,13 @@
 import { type ZodString, type ZodType, z } from "zod";
 
-import { ValidationError } from "./errors";
-import { providerLocaleKey } from "./i18n/keys";
+import { ValidationError } from "./errors.js";
+import { providerLocaleKey } from "./i18n/keys.js";
 import type {
 	InferSchemaOutput,
 	ProviderLocaleKey,
 	SchemaLike,
 	StandardSchemaV1,
-} from "./types";
+} from "./types.js";
 
 export { z };
 
@@ -25,15 +25,11 @@ function isFailureResult<Output>(
 	return "issues" in result;
 }
 function isPromiseResult<Output>(
-	result:
-		| StandardSchemaV1.Result<Output>
-		| Promise<StandardSchemaV1.Result<Output>>,
+	result: StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>,
 ): result is Promise<StandardSchemaV1.Result<Output>> {
 	return result instanceof Promise;
 }
-function formatStandardSchemaIssues(
-	issues: readonly StandardSchemaV1.Issue[],
-): string {
+function formatStandardSchemaIssues(issues: readonly StandardSchemaV1.Issue[]): string {
 	return issues.map((issue) => issue.message).join("; ");
 }
 export function parseSchema<TSchema extends SchemaLike>(
@@ -46,8 +42,7 @@ export async function parseSchema(
 	value: unknown,
 	fieldPath: string,
 ): Promise<unknown> {
-	if ("parse" in schema && typeof schema.parse === "function")
-		return schema.parse(value);
+	if ("parse" in schema && typeof schema.parse === "function") return schema.parse(value);
 	const result = schema["~standard"].validate(value);
 	const resolved = isPromiseResult(result) ? await result : result;
 	if (isFailureResult(resolved))
@@ -78,8 +73,7 @@ export function safeParseSchemaSync(
 					`Schema validation for ${fieldPath} returned a Promise. defineProvider fixture validation requires synchronous Standard Schema validation.`,
 				),
 			};
-		if (isFailureResult(result))
-			return { success: false, error: result.issues };
+		if (isFailureResult(result)) return { success: false, error: result.issues };
 		return { success: true, data: result.value };
 	} catch (error) {
 		return { success: false, error };
@@ -147,9 +141,7 @@ const describeKeyMethod = function <TSchema extends ZodType>(
 };
 
 function installDescribeKeyOnPrototype(prototype: unknown): void {
-	const target = prototype as
-		| (Record<string, unknown> & { describeKey?: unknown })
-		| null;
+	const target = prototype as (Record<string, unknown> & { describeKey?: unknown }) | null;
 	if (!target || typeof target.describeKey === "function") {
 		return;
 	}
@@ -201,12 +193,8 @@ export function field<TSchema extends ZodType>(
 	const metadata = described.meta() ?? {};
 	return described.meta({
 		...metadata,
-		...((options.sensitive ?? true)
-			? { [APIFUSE_SENSITIVE_META_KEY]: true }
-			: {}),
-		...(options.kind
-			? { [APIFUSE_SENSITIVE_KIND_META_KEY]: options.kind }
-			: {}),
+		...((options.sensitive ?? true) ? { [APIFUSE_SENSITIVE_META_KEY]: true } : {}),
+		...(options.kind ? { [APIFUSE_SENSITIVE_KIND_META_KEY]: options.kind } : {}),
 	});
 }
 
@@ -222,10 +210,7 @@ function sensitiveString(
 	description: string,
 	options: { description?: string; minLength?: number } = {},
 ): ZodString {
-	const schema =
-		options.minLength === undefined
-			? z.string()
-			: z.string().min(options.minLength);
+	const schema = options.minLength === undefined ? z.string() : z.string().min(options.minLength);
 	return field(schema, {
 		kind,
 		description: options.description ?? description,
@@ -234,33 +219,17 @@ function sensitiveString(
 
 export const fields = {
 	apiKey: (options?: { description?: string }) =>
-		sensitiveString(
-			"api_key",
-			"Provider API key or credential secret.",
-			options,
-		),
+		sensitiveString("api_key", "Provider API key or credential secret.", options),
 	authorization: (options?: { description?: string }) =>
-		sensitiveString(
-			"authorization",
-			"Authorization header value or bearer credential.",
-			options,
-		),
+		sensitiveString("authorization", "Authorization header value or bearer credential.", options),
 	cookie: (options?: { description?: string }) =>
-		sensitiveString(
-			"cookie",
-			"Cookie header or browser session secret.",
-			options,
-		),
+		sensitiveString("cookie", "Cookie header or browser session secret.", options),
 	otp: (options?: { description?: string }) =>
 		sensitiveString("otp", "One-time verification code.", options),
 	password: (options?: { description?: string; minLength?: number }) =>
 		sensitiveString("password", "Password credential.", options),
 	paymentUrl: (options?: { description?: string }) =>
-		sensitiveString(
-			"payment_url",
-			"Sensitive payment or checkout URL.",
-			options,
-		),
+		sensitiveString("payment_url", "Sensitive payment or checkout URL.", options),
 	phone: (options?: { description?: string }) =>
 		sensitiveString("phone", "Phone number or phone-based identity.", options),
 	secret: (options?: { description?: string }) =>
@@ -271,10 +240,7 @@ export const fields = {
 
 export function isSensitiveSchema(schema: unknown): boolean {
 	const metadata = readZodMetadata(schema);
-	return (
-		metadata !== undefined &&
-		Reflect.get(metadata, APIFUSE_SENSITIVE_META_KEY) === true
-	);
+	return metadata !== undefined && Reflect.get(metadata, APIFUSE_SENSITIVE_META_KEY) === true;
 }
 
 export function collectSensitivePaths(schema: unknown): SensitivePath[] {
@@ -283,10 +249,7 @@ export function collectSensitivePaths(schema: unknown): SensitivePath[] {
 	return out;
 }
 
-export function redactPayload(
-	value: unknown,
-	paths: readonly SensitivePath[] = [],
-): unknown {
+export function redactPayload(value: unknown, paths: readonly SensitivePath[] = []): unknown {
 	return redactValue(value, [], paths);
 }
 
@@ -297,8 +260,7 @@ function collectSensitivePathsInto(
 	activeSchemas: Set<unknown>,
 	emittedPaths: Set<string>,
 ): void {
-	if (!schema || typeof schema !== "object" || activeSchemas.has(schema))
-		return;
+	if (!schema || typeof schema !== "object" || activeSchemas.has(schema)) return;
 	activeSchemas.add(schema);
 	try {
 		if (isSensitiveSchema(schema)) pushSensitivePath(out, emittedPaths, path);
@@ -308,13 +270,7 @@ function collectSensitivePathsInto(
 			case "object": {
 				const shape = readObjectShape(def);
 				for (const [key, child] of Object.entries(shape)) {
-					collectSensitivePathsInto(
-						child,
-						[...path, key],
-						out,
-						activeSchemas,
-						emittedPaths,
-					);
+					collectSensitivePathsInto(child, [...path, key], out, activeSchemas, emittedPaths);
 				}
 				break;
 			}
@@ -341,20 +297,8 @@ function collectSensitivePathsInto(
 				);
 				break;
 			case "pipe":
-				collectSensitivePathsInto(
-					Reflect.get(def, "in"),
-					path,
-					out,
-					activeSchemas,
-					emittedPaths,
-				);
-				collectSensitivePathsInto(
-					Reflect.get(def, "out"),
-					path,
-					out,
-					activeSchemas,
-					emittedPaths,
-				);
+				collectSensitivePathsInto(Reflect.get(def, "in"), path, out, activeSchemas, emittedPaths);
+				collectSensitivePathsInto(Reflect.get(def, "out"), path, out, activeSchemas, emittedPaths);
 				break;
 		}
 	} finally {
@@ -402,18 +346,13 @@ function pathMatches(
 ): boolean {
 	return patterns.some((pattern) => {
 		if (pattern.length !== path.length) return false;
-		return pattern.every(
-			(segment, index) => segment === "*" || segment === path[index],
-		);
+		return pattern.every((segment, index) => segment === "*" || segment === path[index]);
 	});
 }
 
 function isReservedSensitiveKey(key: string): boolean {
 	const normalized = key.toLowerCase().replace(/[-_\s]/g, "");
-	return (
-		RESERVED_SENSITIVE_KEYS.has(normalized) ||
-		RESERVED_SENSITIVE_KEYS.has(key.toLowerCase())
-	);
+	return RESERVED_SENSITIVE_KEYS.has(normalized) || RESERVED_SENSITIVE_KEYS.has(key.toLowerCase());
 }
 
 function readZodMetadata(schema: unknown): object | undefined {

package/src/serve.ts

@@ -1 +1,6 @@
-export { createServerApp, type ServeOptions, serve } from "./server/serve";
+export {
+	createServerApp,
+	createServerAppAsync,
+	type ServeOptions,
+	serve,
+} from "./server/serve.js";

package/src/server/index.ts

@@ -1,30 +1,53 @@
-export { createServerApp, type ServeOptions, serve } from "./serve";
+export {
+	createServerApp,
+	createServerAppAsync,
+	ERROR_OBSERVABILITY_HEADER,
+	type ErrorObservabilityDetails,
+	type ProviderServerCloseOptions,
+	type ProviderServerHandle,
+	type ProviderServerLogEvent,
+	type ProviderServerLogger,
+	type ProviderServerOperationExecutor,
+	type ProviderServerOperationExecutorInput,
+	type ProviderServerOptions,
+	type ProviderServerStatefulForwardEnvelope,
+	type ServeOptions,
+	serve,
+} from "./serve.js";
 export {
 	computeSelfTestPlanDigest,
 	createSelfTestApp,
+	createSelfTestAuthFlowInvoke,
 	createSelfTestInvoke,
 	DEFAULT_SELF_TEST_REQUEST_BUDGET_MS,
 	isSelfTestReadOnlyOperation,
 	PROVIDER_RUNTIME_SELF_TEST_REQUEST_BUDGET_MS_ENV,
 	resolveSelfTestPort,
+	SELF_TEST_AUTH_FLOW_MULTI_TURN_SKIP_REASON,
+	SELF_TEST_AUTH_FLOW_REJECTED_SKIP_REASON,
 	SELF_TEST_HEALTHZ_PATH,
 	SELF_TEST_PATH,
 	SELF_TEST_SCHEMA_VERSION,
 	type SelfTestAppOptions,
+	type SelfTestAuthFlowInvoke,
+	type SelfTestAuthFlowRoute,
 	type SelfTestCaseResult,
 	type SelfTestCaseStatus,
 	type SelfTestOperationInvoke,
 	type SelfTestRequest,
 	SelfTestRequestSchema,
 	type SelfTestResponse,
-} from "./self-test";
-export { resolveHealthCheckInputDateTokens } from "./self-test-input-tokens";
+} from "./self-test.js";
+export {
+	type InputDateTokenCalendar,
+	resolveHealthCheckInputDateTokens,
+} from "./self-test-input-tokens.js";
 export {
 	collectSelfTestSensitiveValues,
 	redactSelfTestText,
 	SELF_TEST_MAX_TEXT_LENGTH,
 	SELF_TEST_REDACTED_PLACEHOLDER,
-} from "./self-test-redaction";
+} from "./self-test-redaction.js";
 export {
 	DEFAULT_SELF_TEST_PORT,
 	deriveSelfTestToken,
@@ -34,7 +57,7 @@ export {
 	resolveSelfTestMasterSecrets,
 	type SelfTestMasterSecrets,
 	verifySelfTestAuthorization,
-} from "./self-test-token";
+} from "./self-test-token.js";
 export type {
 	AuthFlowRequest,
 	AuthFlowResponse,
@@ -45,7 +68,7 @@ export type {
 	OperationRequest,
 	OperationResponse,
 	OperationSuccessResponse,
-} from "./types";
+} from "./types.js";
 export {
 	AuthFlowRequestSchema,
 	AuthFlowSuccessResponseSchema,
@@ -55,4 +78,4 @@ export {
 	OperationErrorResponseSchema,
 	OperationRequestSchema,
 	OperationSuccessResponseSchema,
-} from "./types";
+} from "./types.js";

package/src/server/self-test-input-tokens.ts

@@ -1,46 +1,61 @@
 /**
- * Relative-KST date token resolution for health-check case inputs, ported from
- * the monorepo health-monitor (`apps/health-monitor/src/lib/health-check-input.ts`)
- * so provider self-tests resolve durable probe inputs identically.
+ * Relative date-token resolution for health-check case inputs and fixture
+ * requests. The calendar defaults to KST; callers that need UTC must opt in
+ * explicitly so UTC and KST do not silently disagree from 15:00–23:59 UTC.
  *
- * Supported token: `+<days>d` or `+<days>d:YYYYMMDD` (1..365 days ahead, KST).
+ * Supported token: `+<days>d` or `+<days>d:YYYYMMDD` (1..365 days ahead).
  */
-const RELATIVE_KST_DATE_TOKEN = /^\+(\d{1,3})d(?::(YYYYMMDD))?$/i;
+const RELATIVE_DATE_TOKEN = /^\+(\d{1,3})d(?::(YYYYMMDD))?$/i;
 
-function dateFromKstDaysAhead(
+export type InputDateTokenCalendar = "KST" | "UTC";
+
+function dateFromDaysAhead(
 	daysAhead: number,
 	now = new Date(),
 	format: "YYYY-MM-DD" | "YYYYMMDD" = "YYYY-MM-DD",
+	calendar: InputDateTokenCalendar = "KST",
 ): string {
-	const kstNow = new Date(now.getTime() + 9 * 60 * 60 * 1000);
+	const calendarNow = new Date(now.getTime() + (calendar === "KST" ? 9 * 60 * 60 * 1000 : 0));
 	const date = new Date(
-		Date.UTC(kstNow.getUTCFullYear(), kstNow.getUTCMonth(), kstNow.getUTCDate() + daysAhead),
+		Date.UTC(
+			calendarNow.getUTCFullYear(),
+			calendarNow.getUTCMonth(),
+			calendarNow.getUTCDate() + daysAhead,
+		),
 	);
 	const isoDate = date.toISOString().slice(0, 10);
 	return format === "YYYYMMDD" ? isoDate.replace(/-/g, "") : isoDate;
 }
 
-export function resolveHealthCheckInputDateTokens(value: unknown, now = new Date()): unknown {
+export function resolveHealthCheckInputDateTokens(
+	value: unknown,
+	now = new Date(),
+	calendar: InputDateTokenCalendar = "KST",
+): unknown {
 	if (typeof value === "string") {
-		const relative = value.match(RELATIVE_KST_DATE_TOKEN);
+		const relative = value.match(RELATIVE_DATE_TOKEN);
 		if (!relative) return value;
 		const daysAhead = Number(relative[1]);
 		if (!Number.isInteger(daysAhead) || daysAhead < 1 || daysAhead > 365) {
 			return value;
 		}
 		const format = relative[2]?.toUpperCase() === "YYYYMMDD" ? "YYYYMMDD" : "YYYY-MM-DD";
-		return dateFromKstDaysAhead(daysAhead, now, format);
+		return dateFromDaysAhead(daysAhead, now, format, calendar);
 	}
 	if (Array.isArray(value)) {
-		return value.map((entry) => resolveHealthCheckInputDateTokens(entry, now));
+		const resolved = value.map((entry) => resolveHealthCheckInputDateTokens(entry, now, calendar));
+		return resolved.some((entry, index) => entry !== value[index]) ? resolved : value;
 	}
 	if (value && typeof value === "object") {
-		return Object.fromEntries(
+		const resolved = Object.fromEntries(
 			Object.entries(value).map(([key, entry]) => [
 				key,
-				resolveHealthCheckInputDateTokens(entry, now),
+				resolveHealthCheckInputDateTokens(entry, now, calendar),
 			]),
 		);
+		return Object.entries(resolved).some(([key, entry]) => entry !== Reflect.get(value, key))
+			? resolved
+			: value;
 	}
 	return value;
 }

package/src/server/self-test-redaction.ts

@@ -1,8 +1,8 @@
-import type { ProviderDefinition } from "../types";
+import type { ProviderDefinition } from "../types.js";
 import {
 	PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_ENV,
 	PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_PREVIOUS_ENV,
-} from "./self-test-token";
+} from "./self-test-token.js";
 
 export const SELF_TEST_REDACTED_PLACEHOLDER = "[REDACTED]";