@ductape/sdk 0.1.8 → 0.1.9

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

@@ -0,0 +1,515 @@
+/**
+ * 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",
+    GRAPH = "graph",
+    MESSAGE_BROKER = "message_broker",
+    STORAGE = "storage"
+}
+/**
+ * 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;
+    graph?: string;
+    messageBroker?: string;
+    storage?: 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;
+    graph(tag: string): IGraphProbeBuilder;
+    messageBroker(tag: string): IMessageBrokerProbeBuilder;
+    storage(tag: string): IStorageProbeBuilder;
+}
+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;
+}
+export interface IGraphProbeBuilder {
+    action(event: string): IGraphProbeActionBuilder;
+}
+export interface IGraphProbeActionBuilder {
+    input(data: Record<string, unknown>): void;
+}
+export interface IMessageBrokerProbeBuilder {
+    action(event: string): IMessageBrokerProbeActionBuilder;
+}
+export interface IMessageBrokerProbeActionBuilder {
+    input(data: Record<string, unknown>): void;
+}
+export interface IStorageProbeBuilder {
+    action(event: string): IStorageProbeActionBuilder;
+}
+export interface IStorageProbeActionBuilder {
+    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;
+    /** Redis client for caching healthcheck results */
+    redis_client?: any;
+    /** BullMQ queues for job scheduling */
+    queues?: {
+        health?: any;
+        jobs?: any;
+    };
+    default_product?: string;
+    default_env?: 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,29 @@
+"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["GRAPH"] = "graph";
+    ProbeType["MESSAGE_BROKER"] = "message_broker";
+    ProbeType["STORAGE"] = "storage";
+})(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;AAgCZ,kGApCP,yBAAiB,OAoCO;AA1BQ,+FAPd,sBAAqB,OAOO;AAEhD,+EAA+E;AAC/E,QAAQ;AACR,+EAA+E;AAE/E;;GAEG;AACH,IAAY,SAQX;AARD,WAAY,SAAS;IACnB,wBAAW,CAAA;IACX,kCAAqB,CAAA;IACrB,kCAAqB,CAAA;IACrB,gCAAmB,CAAA;IACnB,4BAAe,CAAA;IACf,8CAAiC,CAAA;IACjC,gCAAmB,CAAA;AACrB,CAAC,EARW,SAAS,yBAAT,SAAS,QAQpB"}

package/dist/runtime/runtime-defaults.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Product/env defaults are set only on `new Ductape({ accessKey, product, env })`.
+ */
+export interface IRuntimeDefaults {
+    default_product?: string;
+    default_env?: string;
+}
+export interface IProductEnvFields {
+    product?: string;
+    env?: string;
+}
+export declare function mergeProductEnv<T extends IProductEnvFields>(options: T, defaults: IRuntimeDefaults, context?: IProductEnvFields | null): T & {
+    product: string;
+    env: string;
+};
+/** Resolves product/env from call payload, connection context, then constructor defaults. */
+export declare class ProductEnvResolver {
+    private readonly defaults;
+    constructor(defaults?: IRuntimeDefaults);
+    resolve<T extends IProductEnvFields>(options: T, context?: IProductEnvFields | null): T & {
+        product: string;
+        env: string;
+    };
+}
+export declare function runtimeDefaultsFromConfig(config: {
+    default_product?: string;
+    default_env?: string;
+}): IRuntimeDefaults;

package/dist/runtime/runtime-defaults.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Product/env defaults are set only on `new Ductape({ accessKey, product, env })`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductEnvResolver = void 0;
+exports.mergeProductEnv = mergeProductEnv;
+exports.runtimeDefaultsFromConfig = runtimeDefaultsFromConfig;
+function mergeProductEnv(options, defaults, context) {
+    var _a, _b, _c, _d, _e, _f;
+    const product = ((_a = options.product) === null || _a === void 0 ? void 0 : _a.trim()) ||
+        ((_b = context === null || context === void 0 ? void 0 : context.product) === null || _b === void 0 ? void 0 : _b.trim()) ||
+        ((_c = defaults.default_product) === null || _c === void 0 ? void 0 : _c.trim()) ||
+        '';
+    const env = ((_d = options.env) === null || _d === void 0 ? void 0 : _d.trim()) || ((_e = context === null || context === void 0 ? void 0 : context.env) === null || _e === void 0 ? void 0 : _e.trim()) || ((_f = defaults.default_env) === null || _f === void 0 ? void 0 : _f.trim()) || '';
+    if (!product || !env) {
+        throw new Error('product and env are required. Pass them in the call or set both on the Ductape constructor: ' +
+            'new Ductape({ accessKey, product, env }).');
+    }
+    return Object.assign(Object.assign({}, options), { product, env });
+}
+/** Resolves product/env from call payload, connection context, then constructor defaults. */
+class ProductEnvResolver {
+    constructor(defaults = {}) {
+        this.defaults = defaults;
+    }
+    resolve(options, context) {
+        return mergeProductEnv(options, this.defaults, context);
+    }
+}
+exports.ProductEnvResolver = ProductEnvResolver;
+function runtimeDefaultsFromConfig(config) {
+    return {
+        default_product: config.default_product,
+        default_env: config.default_env,
+    };
+}
+//# sourceMappingURL=runtime-defaults.js.map

package/dist/runtime/runtime-defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-defaults.js","sourceRoot":"","sources":["../../src/runtime/runtime-defaults.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAYH,0CAqBC;AAcD,8DAQC;AA3CD,SAAgB,eAAe,CAC7B,OAAU,EACV,QAA0B,EAC1B,OAAkC;;IAElC,MAAM,OAAO,GACX,CAAA,MAAA,OAAO,CAAC,OAAO,0CAAE,IAAI,EAAE;SACvB,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,OAAO,0CAAE,IAAI,EAAE,CAAA;SACxB,MAAA,QAAQ,CAAC,eAAe,0CAAE,IAAI,EAAE,CAAA;QAChC,EAAE,CAAC;IACL,MAAM,GAAG,GACP,CAAA,MAAA,OAAO,CAAC,GAAG,0CAAE,IAAI,EAAE,MAAI,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,GAAG,0CAAE,IAAI,EAAE,CAAA,KAAI,MAAA,QAAQ,CAAC,WAAW,0CAAE,IAAI,EAAE,CAAA,IAAI,EAAE,CAAC;IAEpF,IAAI,CAAC,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CACb,8FAA8F;YAC5F,2CAA2C,CAC9C,CAAC;IACJ,CAAC;IAED,uCAAY,OAAO,KAAE,OAAO,EAAE,GAAG,IAAG;AACtC,CAAC;AAED,6FAA6F;AAC7F,MAAa,kBAAkB;IAC7B,YAA6B,WAA6B,EAAE;QAA/B,aAAQ,GAAR,QAAQ,CAAuB;IAAG,CAAC;IAEhE,OAAO,CACL,OAAU,EACV,OAAkC;QAElC,OAAO,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC1D,CAAC;CACF;AATD,gDASC;AAED,SAAgB,yBAAyB,CAAC,MAGzC;IACC,OAAO;QACL,eAAe,EAAE,MAAM,CAAC,eAAe;QACvC,WAAW,EAAE,MAAM,CAAC,WAAW;KAChC,CAAC;AACJ,CAAC"}

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"}