@ductape/sdk 0.0.4-v51 → 0.0.4-v53

package/dist/resilience/types/index.d.ts

@@ -0,0 +1,479 @@
+/**
+ * Ductape Resilience Types
+ *
+ * Type definitions for healthchecks, quotas, and fallbacks.
+ * Aligned with backend types in productsBuilder.types.ts
+ */
+import { FeatureEventTypes, IFeatureInput, IActionRequest, ProviderStatus as BackendProviderStatus } from '../../types';
+export { IFeatureInput };
+export { BackendProviderStatus as ProviderStatus };
+/**
+ * Type of probe for healthchecks
+ */
+export declare enum ProbeType {
+    APP = "app",
+    DATABASE = "database",
+    WORKFLOW = "workflow",
+    FEATURE = "feature"
+}
+/**
+ * Type of resilience provider event
+ * Uses ACTION only - features are deprecated in favor of workflows
+ */
+export type ResilienceEventType = FeatureEventTypes.ACTION;
+export { FeatureEventTypes };
+/**
+ * Healthcheck probe configuration (for code-first API)
+ */
+export interface IHealthcheckProbe {
+    type: ProbeType;
+    app?: string;
+    database?: string;
+    workflow?: string;
+    feature?: string;
+    event?: string;
+    input?: Record<string, unknown>;
+}
+/**
+ * Healthcheck environment configuration
+ * Matches backend CheckEnvStatus interface
+ */
+export interface IHealthcheckEnvConfig {
+    slug: string;
+    status?: string;
+    lastAvailable?: string;
+    lastChecked?: string;
+    lastLatency?: string;
+    averageLatency?: string;
+    input?: any;
+}
+/**
+ * Webhook configuration for failure notifications
+ */
+export interface IHealthcheckWebhook {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH';
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}
+/**
+ * Notification channel configuration
+ */
+export interface INotificationChannel {
+    push?: {
+        recipients?: string[];
+    };
+    email?: {
+        recipients: string[];
+    };
+    sms?: {
+        recipients: string[];
+    };
+    callback?: {
+        data?: Record<string, unknown>;
+    };
+}
+/**
+ * Notification configuration for healthcheck failures
+ */
+export interface IHealthcheckNotification {
+    notification: string;
+    message: string;
+    channels: INotificationChannel;
+}
+/**
+ * Event emission configuration
+ */
+export interface IHealthcheckEmit {
+    event: string;
+    data?: Record<string, unknown>;
+}
+/**
+ * On-failure configuration for healthchecks
+ */
+export interface IHealthcheckOnFailure {
+    notifications?: IHealthcheckNotification[];
+    webhooks?: IHealthcheckWebhook[];
+    emit?: IHealthcheckEmit[];
+}
+/**
+ * Healthcheck definition schema
+ * Compatible with backend IProductAppHealth
+ */
+export interface IHealthcheckSchema {
+    _id?: string;
+    tag: string;
+    name?: string;
+    description?: string;
+    app?: string;
+    event?: string;
+    probe?: IHealthcheckProbe;
+    interval: number;
+    retries: number;
+    onFailure?: IHealthcheckOnFailure;
+    envs: IHealthcheckEnvConfig[];
+}
+/**
+ * Healthcheck status response
+ */
+export interface IHealthcheckStatus {
+    status: string;
+    lastAvailable?: string;
+    lastChecked?: string;
+    lastLatency?: number;
+    averageLatency?: number;
+}
+/**
+ * Healthcheck run result
+ */
+export interface IHealthcheckRunResult {
+    status: string;
+    latency: number;
+    checkedAt: string;
+    error?: string;
+}
+/**
+ * Quota provider option configuration
+ * Compatible with backend IQuotaOptions (extends IFallbackOptions)
+ * Note: Features are deprecated - use workflows instead
+ */
+export interface IQuotaOption {
+    quota: number;
+    uses?: number;
+    provider?: string;
+    app?: string;
+    type: FeatureEventTypes.ACTION;
+    event: string;
+    input: IActionRequest | Record<string, unknown>;
+    output: Record<string, unknown>;
+    retries: number;
+    healthcheck?: string;
+    provider_status?: BackendProviderStatus;
+    last_available?: boolean;
+    last_checked?: Date;
+    check_interval?: number;
+}
+/**
+ * Quota definition schema
+ * Compatible with backend IProductQuota
+ */
+export interface IQuotaSchema {
+    _id?: string;
+    name?: string;
+    description?: string;
+    tag: string;
+    input: Record<string, IFeatureInput>;
+    total_quota?: number;
+    total_init?: number;
+    options: IQuotaOption[];
+}
+/**
+ * Quota run options
+ */
+export interface IQuotaRunOptions {
+    product: string;
+    env: string;
+    tag: string;
+    input: Record<string, unknown>;
+    /** Session token in format: session_tag:jwt_token */
+    session?: string;
+    cache?: string;
+}
+/**
+ * Quota dispatch options
+ */
+export interface IQuotaDispatchOptions extends IQuotaRunOptions {
+    schedule?: {
+        cron?: string;
+        delay?: number;
+        at?: Date;
+    };
+}
+/**
+ * Fallback provider option configuration
+ * Compatible with backend IFallbackOptions
+ * Note: Features are deprecated - use workflows instead
+ */
+export interface IFallbackOption {
+    provider?: string;
+    app?: string;
+    type: FeatureEventTypes.ACTION;
+    event: string;
+    input: IActionRequest | Record<string, unknown>;
+    output: Record<string, unknown>;
+    retries: number;
+    healthcheck?: string;
+    provider_status?: BackendProviderStatus;
+    last_available?: boolean;
+    last_checked?: Date;
+    check_interval?: number;
+}
+/**
+ * Fallback definition schema
+ * Compatible with backend IProductFallback
+ */
+export interface IFallbackSchema {
+    _id?: string;
+    name?: string;
+    description?: string;
+    tag: string;
+    input: Record<string, IFeatureInput>;
+    options: IFallbackOption[];
+}
+/**
+ * Fallback run options
+ */
+export interface IFallbackRunOptions {
+    product: string;
+    env: string;
+    tag: string;
+    input: Record<string, unknown>;
+    /** Session token in format: session_tag:jwt_token */
+    session?: string;
+    cache?: string;
+}
+/**
+ * Fallback dispatch options
+ */
+export interface IFallbackDispatchOptions extends IFallbackRunOptions {
+    schedule?: {
+        cron?: string;
+        delay?: number;
+        at?: Date;
+    };
+}
+/**
+ * Probe builder interface for healthchecks
+ */
+export interface IProbeBuilder {
+    app(tag: string): IAppProbeBuilder;
+    database(tag: string): IDatabaseProbeBuilder;
+    workflow(tag: string): IWorkflowProbeBuilder;
+}
+export interface IAppProbeBuilder {
+    action(event: string): IAppProbeActionBuilder;
+}
+export interface IAppProbeActionBuilder {
+    input(data: Record<string, unknown>): void;
+}
+export interface IDatabaseProbeBuilder {
+    action(event: string): IDatabaseProbeActionBuilder;
+}
+export interface IDatabaseProbeActionBuilder {
+    input(data: Record<string, unknown>): void;
+}
+export interface IWorkflowProbeBuilder {
+    input(data: Record<string, unknown>): void;
+}
+/**
+ * Failure notification builder interface
+ */
+export interface IFailureNotificationBuilder {
+    notification(tag: string): INotificationMessageBuilder;
+    webhook(config: IHealthcheckWebhook): IFailureNotificationBuilder;
+    emit(config: IHealthcheckEmit): IFailureNotificationBuilder;
+}
+export interface INotificationMessageBuilder {
+    message(event: string): INotificationChannelBuilder;
+}
+export interface INotificationChannelBuilder extends IFailureNotificationBuilder {
+    push(config?: {
+        recipients?: string[];
+    }): INotificationChannelBuilder;
+    email(config: {
+        recipients: string[];
+    }): INotificationChannelBuilder;
+    sms(config: {
+        recipients: string[];
+    }): INotificationChannelBuilder;
+    callback(config?: {
+        data?: Record<string, unknown>;
+    }): INotificationChannelBuilder;
+}
+/**
+ * Healthcheck context interface
+ */
+export interface IHealthcheckContext {
+    probe(): IProbeBuilder;
+    interval(ms: number): void;
+    retries(count: number): void;
+    env(slug: string, options?: Partial<IHealthcheckEnvConfig>): void;
+    onFailure(): IFailureNotificationBuilder;
+    auth(field: string): string;
+    token(key: string): string;
+    variable(app: string, key: string): string;
+    constant(app: string, key: string): string;
+}
+/**
+ * Provider builder interface for quotas and fallbacks
+ */
+export interface IProviderBuilder<TInput = Record<string, unknown>> {
+    weight(value: number): IProviderBuilder<TInput>;
+    healthcheck(tag: string): IProviderBuilder<TInput>;
+    app(tag: string): IAppProviderBuilder<TInput>;
+    /** @deprecated Features are deprecated - use workflow() instead */
+    feature(tag: string): IProviderBuilder<TInput>;
+    database(tag: string): IDatabaseProviderBuilder<TInput>;
+    workflow(tag: string): IWorkflowProviderBuilder<TInput>;
+    notification(tag: string): INotificationProviderBuilder<TInput>;
+    mapInput(mapper: (input: TInput) => Record<string, unknown>): IProviderBuilder<TInput>;
+    mapOutput(mapper: (response: unknown) => Record<string, unknown>): IProviderBuilder<TInput>;
+    retries(count: number): IProviderBuilder<TInput>;
+    checkInterval(ms: number): IProviderBuilder<TInput>;
+}
+export interface IAppProviderBuilder<TInput> extends IProviderBuilder<TInput> {
+    action(event: string): IProviderBuilder<TInput>;
+}
+export interface IDatabaseProviderBuilder<TInput> extends IProviderBuilder<TInput> {
+    action(event: string): IProviderBuilder<TInput>;
+}
+export interface IWorkflowProviderBuilder<TInput> extends IProviderBuilder<TInput> {
+    input(data: Record<string, unknown>): IProviderBuilder<TInput>;
+}
+export interface INotificationProviderBuilder<TInput> extends IProviderBuilder<TInput> {
+    event(event: string): IProviderBuilder<TInput>;
+}
+/**
+ * Quota context interface
+ */
+export interface IQuotaContext<TInput = Record<string, unknown>> {
+    readonly input: TInput;
+    provider(name: string): IProviderBuilder<TInput>;
+    auth(field: string): string;
+    token(key: string): string;
+    variable(app: string, key: string): string;
+    constant(app: string, key: string): string;
+}
+/**
+ * Fallback provider builder interface
+ */
+export interface IFallbackProviderBuilder<TInput = Record<string, unknown>> extends IProviderBuilder<TInput> {
+}
+/**
+ * Fallback context interface
+ */
+export interface IFallbackContext<TInput = Record<string, unknown>> {
+    readonly input: TInput;
+    primary(name: string): IFallbackProviderBuilder<TInput>;
+    fallback(name: string): IFallbackProviderBuilder<TInput>;
+    auth(field: string): string;
+    token(key: string): string;
+    variable(app: string, key: string): string;
+    constant(app: string, key: string): string;
+}
+/**
+ * Healthcheck define options
+ */
+export interface IHealthcheckDefineOptions {
+    product?: string;
+    tag: string;
+    name?: string;
+    description?: string;
+    handler: (ctx: IHealthcheckContext) => Promise<void>;
+}
+/**
+ * Quota define options
+ */
+export interface IQuotaDefineOptions<TInput = Record<string, unknown>> {
+    product?: string;
+    tag: string;
+    name?: string;
+    description?: string;
+    input: Record<string, IFeatureInput>;
+    handler: (ctx: IQuotaContext<TInput>) => Promise<void>;
+}
+/**
+ * Fallback define options
+ */
+export interface IFallbackDefineOptions<TInput = Record<string, unknown>> {
+    product?: string;
+    tag: string;
+    name?: string;
+    description?: string;
+    input: Record<string, IFeatureInput>;
+    handler: (ctx: IFallbackContext<TInput>) => Promise<void>;
+}
+/**
+ * Resilience service configuration
+ */
+export interface IResilienceServiceConfig {
+    workspace_id: string;
+    public_key: string;
+    user_id: string;
+    token: string;
+    env_type: string;
+    base_url?: string;
+}
+/**
+ * Defined healthcheck with compile method
+ */
+export interface IDefinedHealthcheck {
+    tag: string;
+    name?: string;
+    description?: string;
+    compile(): IHealthcheckSchema;
+}
+/**
+ * Defined quota with compile method
+ */
+export interface IDefinedQuota {
+    tag: string;
+    name?: string;
+    description?: string;
+    input: Record<string, IFeatureInput>;
+    compile(): IQuotaSchema;
+}
+/**
+ * Defined fallback with compile method
+ */
+export interface IDefinedFallback {
+    tag: string;
+    name?: string;
+    description?: string;
+    input: Record<string, IFeatureInput>;
+    compile(): IFallbackSchema;
+}
+/**
+ * Combined resilience definition options
+ */
+export interface IResilienceDefineOptions {
+    tag: string;
+    name?: string;
+    description?: string;
+    handler: (ctx: IResilienceContext) => Promise<void>;
+}
+/**
+ * Combined resilience context
+ */
+export interface IResilienceContext {
+    healthcheck(tag: string): IHealthcheckBuilder;
+    quota(tag: string, options: {
+        input: Record<string, IFeatureInput>;
+    }): IQuotaBuilder;
+    fallback(tag: string, options: {
+        input: Record<string, IFeatureInput>;
+    }): IFallbackBuilder;
+}
+/**
+ * Healthcheck builder in resilience context
+ */
+export interface IHealthcheckBuilder {
+    probe(): IProbeBuilder;
+    interval(ms: number): IHealthcheckBuilder;
+    retries(count: number): IHealthcheckBuilder;
+    env(slug: string, options?: Partial<IHealthcheckEnvConfig>): IHealthcheckBuilder;
+    onFailure(): IFailureNotificationBuilder;
+}
+/**
+ * Quota builder in resilience context
+ */
+export interface IQuotaBuilder {
+    provider(name: string): IProviderBuilder;
+}
+/**
+ * Fallback builder in resilience context
+ */
+export interface IFallbackBuilder {
+    primary(name: string): IFallbackProviderBuilder;
+    fallback(name: string): IFallbackProviderBuilder;
+}

package/dist/resilience/types/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Ductape Resilience Types
+ *
+ * Type definitions for healthchecks, quotas, and fallbacks.
+ * Aligned with backend types in productsBuilder.types.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureEventTypes = exports.ProbeType = exports.ProviderStatus = void 0;
+const types_1 = require("../../types");
+Object.defineProperty(exports, "FeatureEventTypes", { enumerable: true, get: function () { return types_1.FeatureEventTypes; } });
+Object.defineProperty(exports, "ProviderStatus", { enumerable: true, get: function () { return types_1.ProviderStatus; } });
+// ============================================================================
+// Enums
+// ============================================================================
+/**
+ * Type of probe for healthchecks
+ */
+var ProbeType;
+(function (ProbeType) {
+    ProbeType["APP"] = "app";
+    ProbeType["DATABASE"] = "database";
+    ProbeType["WORKFLOW"] = "workflow";
+    ProbeType["FEATURE"] = "feature";
+})(ProbeType || (exports.ProbeType = ProbeType = {}));
+//# sourceMappingURL=index.js.map

package/dist/resilience/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/resilience/types/index.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAEH,uCAKqB;AA6BZ,kGAjCP,yBAAiB,OAiCO;AAvBQ,+FAPd,sBAAqB,OAOO;AAEhD,+EAA+E;AAC/E,QAAQ;AACR,+EAA+E;AAE/E;;GAEG;AACH,IAAY,SAKX;AALD,WAAY,SAAS;IACnB,wBAAW,CAAA;IACX,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,gCAAmB,CAAA;AACrB,CAAC,EALW,SAAS,yBAAT,SAAS,QAKpB"}

package/dist/secrets/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Secrets Module
+ *
+ * Provides workspace secrets management with $Secret{key} syntax support.
+ */
+export { SecretsService, getSecretsService, setSecretsService } from './secrets.service';
+export type { ISecretsServiceDeps } from './secrets.service';
+export { SECRET_PATTERN, SECRET_PATTERN_GLOBAL, SecretNotFoundError, SecretScopeError, SecretEnvironmentError, SecretExpiredError, SecretRevokedError, SecretResolutionError, } from './secrets.types';
+export type { SecretTokenType, ICreateSecretInput, IUpdateSecretInput, ISecretMetadata, ISecret, ISecretCheck, IResolveSecretsOptions, ISecretResolutionResult, ISecretsServiceConfig, ISecretsService, } from './secrets.types';
+export { isSecretReference, containsSecretReferences, extractSecretKeys, validateSecret, findAllSecretReferences, createSecretsResolver, mightContainSecrets, } from './secrets.resolver';

package/dist/secrets/index.js

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * Secrets Module
+ *
+ * Provides workspace secrets management with $Secret{key} syntax support.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mightContainSecrets = exports.createSecretsResolver = exports.findAllSecretReferences = exports.validateSecret = exports.extractSecretKeys = exports.containsSecretReferences = exports.isSecretReference = exports.SecretResolutionError = exports.SecretRevokedError = exports.SecretExpiredError = exports.SecretEnvironmentError = exports.SecretScopeError = exports.SecretNotFoundError = exports.SECRET_PATTERN_GLOBAL = exports.SECRET_PATTERN = exports.setSecretsService = exports.getSecretsService = exports.SecretsService = void 0;
+// Main service
+var secrets_service_1 = require("./secrets.service");
+Object.defineProperty(exports, "SecretsService", { enumerable: true, get: function () { return secrets_service_1.SecretsService; } });
+Object.defineProperty(exports, "getSecretsService", { enumerable: true, get: function () { return secrets_service_1.getSecretsService; } });
+Object.defineProperty(exports, "setSecretsService", { enumerable: true, get: function () { return secrets_service_1.setSecretsService; } });
+// Types
+var secrets_types_1 = require("./secrets.types");
+Object.defineProperty(exports, "SECRET_PATTERN", { enumerable: true, get: function () { return secrets_types_1.SECRET_PATTERN; } });
+Object.defineProperty(exports, "SECRET_PATTERN_GLOBAL", { enumerable: true, get: function () { return secrets_types_1.SECRET_PATTERN_GLOBAL; } });
+Object.defineProperty(exports, "SecretNotFoundError", { enumerable: true, get: function () { return secrets_types_1.SecretNotFoundError; } });
+Object.defineProperty(exports, "SecretScopeError", { enumerable: true, get: function () { return secrets_types_1.SecretScopeError; } });
+Object.defineProperty(exports, "SecretEnvironmentError", { enumerable: true, get: function () { return secrets_types_1.SecretEnvironmentError; } });
+Object.defineProperty(exports, "SecretExpiredError", { enumerable: true, get: function () { return secrets_types_1.SecretExpiredError; } });
+Object.defineProperty(exports, "SecretRevokedError", { enumerable: true, get: function () { return secrets_types_1.SecretRevokedError; } });
+Object.defineProperty(exports, "SecretResolutionError", { enumerable: true, get: function () { return secrets_types_1.SecretResolutionError; } });
+// Resolver utilities
+var secrets_resolver_1 = require("./secrets.resolver");
+Object.defineProperty(exports, "isSecretReference", { enumerable: true, get: function () { return secrets_resolver_1.isSecretReference; } });
+Object.defineProperty(exports, "containsSecretReferences", { enumerable: true, get: function () { return secrets_resolver_1.containsSecretReferences; } });
+Object.defineProperty(exports, "extractSecretKeys", { enumerable: true, get: function () { return secrets_resolver_1.extractSecretKeys; } });
+Object.defineProperty(exports, "validateSecret", { enumerable: true, get: function () { return secrets_resolver_1.validateSecret; } });
+Object.defineProperty(exports, "findAllSecretReferences", { enumerable: true, get: function () { return secrets_resolver_1.findAllSecretReferences; } });
+Object.defineProperty(exports, "createSecretsResolver", { enumerable: true, get: function () { return secrets_resolver_1.createSecretsResolver; } });
+Object.defineProperty(exports, "mightContainSecrets", { enumerable: true, get: function () { return secrets_resolver_1.mightContainSecrets; } });
+//# sourceMappingURL=index.js.map

package/dist/secrets/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/secrets/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,eAAe;AACf,qDAAyF;AAAhF,iHAAA,cAAc,OAAA;AAAE,oHAAA,iBAAiB,OAAA;AAAE,oHAAA,iBAAiB,OAAA;AAG7D,QAAQ;AACR,iDASyB;AARvB,+GAAA,cAAc,OAAA;AACd,sHAAA,qBAAqB,OAAA;AACrB,oHAAA,mBAAmB,OAAA;AACnB,iHAAA,gBAAgB,OAAA;AAChB,uHAAA,sBAAsB,OAAA;AACtB,mHAAA,kBAAkB,OAAA;AAClB,mHAAA,kBAAkB,OAAA;AAClB,sHAAA,qBAAqB,OAAA;AAevB,qBAAqB;AACrB,uDAQ4B;AAP1B,qHAAA,iBAAiB,OAAA;AACjB,4HAAA,wBAAwB,OAAA;AACxB,qHAAA,iBAAiB,OAAA;AACjB,kHAAA,cAAc,OAAA;AACd,2HAAA,uBAAuB,OAAA;AACvB,yHAAA,qBAAqB,OAAA;AACrB,uHAAA,mBAAmB,OAAA"}

package/dist/secrets/secrets.resolver.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Secrets Resolver
+ *
+ * Utility for detecting and resolving $Secret{key} patterns at runtime.
+ * This module handles:
+ * - Pattern detection in strings and objects
+ * - Secret fetching and caching
+ * - Validation of scope and environment constraints
+ * - Recursive resolution of nested objects
+ */
+import { ISecretCheck, ISecret, IResolveSecretsOptions, ISecretResolutionResult } from './secrets.types';
+/**
+ * Check if a string value is a secret reference
+ */
+export declare function isSecretReference(value: string): ISecretCheck;
+/**
+ * Check if a string contains any secret references (partial matches)
+ */
+export declare function containsSecretReferences(value: string): boolean;
+/**
+ * Extract all secret keys from a string
+ */
+export declare function extractSecretKeys(value: string): string[];
+/**
+ * Validate a secret against scope, environment, expiration, and revocation status
+ */
+export declare function validateSecret(secret: ISecret, options?: IResolveSecretsOptions): void;
+/**
+ * Replace a single secret reference with its value
+ */
+export declare function replaceSecretInString(value: string, secretKey: string, secretValue: string): string;
+/**
+ * Recursively find all secret references in an object
+ */
+export declare function findAllSecretReferences(obj: unknown): string[];
+/**
+ * Create a secrets resolver instance with caching
+ */
+export declare function createSecretsResolver(fetchSecret: (key: string) => Promise<ISecret>, options?: {
+    cacheTtl?: number;
+}): {
+    getSecret: (key: string) => Promise<ISecret>;
+    resolveString: (value: string, resolveOptions?: IResolveSecretsOptions) => Promise<ISecretResolutionResult<string>>;
+    resolveObject: <T>(obj: T, resolveOptions?: IResolveSecretsOptions) => Promise<ISecretResolutionResult<T>>;
+    clearCache: () => void;
+    invalidate: (key: string) => void;
+    findAllSecretReferences: typeof findAllSecretReferences;
+};
+/**
+ * Type guard to check if a value might contain secrets
+ */
+export declare function mightContainSecrets(value: unknown): boolean;