nestjs-infisical 1.0.13 → 2.0.0

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from './infisical.module';
-export * from './infisical.types';
+export { loadInfisical } from './load-infisical';
+export type { InfisicalOptions } from './infisical.types';

package/dist/index.js

@@ -1,18 +1,5 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./infisical.module"), exports);
-__exportStar(require("./infisical.types"), exports);
+exports.loadInfisical = void 0;
+var load_infisical_1 = require("./load-infisical");
+Object.defineProperty(exports, "loadInfisical", { enumerable: true, get: function () { return load_infisical_1.loadInfisical; } });

package/dist/infisical.http.d.ts

@@ -0,0 +1,7 @@
+export declare function fetchInfisicalSecrets(options: {
+    baseUrl: string;
+    token: string;
+    projectId: string;
+    environment: string;
+    debug?: boolean;
+}): Promise<Record<string, string>>;

package/dist/infisical.http.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchInfisicalSecrets = fetchInfisicalSecrets;
+const infisical_logger_1 = require("./infisical.logger");
+async function fetchInfisicalSecrets(options) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    try {
+        (0, infisical_logger_1.debugLog)(options.debug, 'Calling Infisical HTTP API');
+        const url = new URL(`${options.baseUrl}/api/v3/secrets/raw`);
+        url.searchParams.set('projectId', options.projectId);
+        url.searchParams.set('environment', options.environment);
+        const response = await fetch(url.toString(), {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${options.token}`,
+                Accept: 'application/json',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`Infisical API ${response.status}: ${text}`);
+        }
+        const json = (await response.json());
+        const secrets = {};
+        json.secrets.map((item) => {
+            secrets[item.secretKey] = item.secretValue;
+            return item;
+        });
+        return secrets;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/infisical.logger.d.ts

@@ -0,0 +1 @@
+export declare function debugLog(enabled: boolean | undefined, message: string): void;

package/dist/infisical.logger.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debugLog = debugLog;
+const PREFIX = '[nestjs-infisical]';
+function debugLog(enabled, message) {
+    if (enabled) {
+        console.log(`${PREFIX} ${message}`);
+    }
+}

package/dist/infisical.types.d.ts

@@ -1,6 +1,5 @@
 import { DotenvConfigOptions } from 'dotenv';
-import { ModuleMetadata } from '@nestjs/common';
-export interface InfisicalModuleOptions {
+export interface InfisicalOptions {
     baseUrl?: string;
     token?: string;
     projectId?: string;
@@ -10,7 +9,12 @@ export interface InfisicalModuleOptions {
     failFast?: boolean;
     debug?: boolean;
 }
-export interface InfisicalModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    inject?: any[];
-    useFactory: (...args: any[]) => Promise<InfisicalModuleOptions> | InfisicalModuleOptions;
+export interface InfisicalSecretItem {
+    id: string;
+    environment: string;
+    type: string;
+    secretKey: string;
+    secretValue: string;
+    createdAt: string;
+    updatedAt: string;
 }

package/dist/load-infisical.d.ts

@@ -0,0 +1,2 @@
+import { InfisicalOptions } from './infisical.types';
+export declare function loadInfisical(options?: InfisicalOptions): Promise<void>;

package/dist/load-infisical.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadInfisical = loadInfisical;
+const dotenv_1 = __importDefault(require("dotenv"));
+const infisical_http_1 = require("./infisical.http");
+const infisical_logger_1 = require("./infisical.logger");
+const LOG_PREFIX = '[nestjs-infisical]';
+async function loadInfisical(options = {}) {
+    const { dotenv: dotenvOptions, override = true, failFast = true, debug = false, } = options;
+    // 1️⃣ Load dotenv FIRST
+    if (dotenvOptions !== false) {
+        (0, infisical_logger_1.debugLog)(debug, 'Loading dotenv configuration');
+        dotenv_1.default.config(dotenvOptions);
+    }
+    // 2️⃣ Resolve config (options → env)
+    const resolved = {
+        baseUrl: options.baseUrl ??
+            process.env.INFISICAL_BASE_URL ??
+            'https://app.infisical.com',
+        token: options.token ?? process.env.INFISICAL_TOKEN,
+        projectId: options.projectId ?? process.env.INFISICAL_PROJECT_ID,
+        environment: options.environment ?? process.env.INFISICAL_ENVIRONMENT,
+    };
+    const providedCount = Object.values(resolved).filter(Boolean).length;
+    (0, infisical_logger_1.debugLog)(debug, `Infisical config resolved: ${providedCount === 0
+        ? 'none'
+        : providedCount === 4
+            ? 'complete'
+            : 'partial'}`);
+    // 3️⃣ No config → silently skip
+    if (providedCount === 0) {
+        (0, infisical_logger_1.debugLog)(debug, 'No Infisical configuration provided. Skipping.');
+        return;
+    }
+    // 4️⃣ Partial config → warn & skip
+    if (providedCount !== 4) {
+        console.warn(`${LOG_PREFIX} Partial Infisical configuration detected. Secrets will not be loaded.`);
+        return;
+    }
+    try {
+        (0, infisical_logger_1.debugLog)(debug, 'Fetching Infisical secrets');
+        const secrets = await (0, infisical_http_1.fetchInfisicalSecrets)({
+            baseUrl: resolved.baseUrl,
+            token: resolved.token.trim(),
+            projectId: resolved.projectId,
+            environment: resolved.environment,
+            debug,
+        });
+        for (const [key, value] of Object.entries(secrets)) {
+            if (override || process.env[key] === undefined) {
+                process.env[key] = value;
+            }
+        }
+        (0, infisical_logger_1.debugLog)(debug, `Loaded ${Object.keys(secrets).length} secrets from Infisical`);
+    }
+    catch (err) {
+        if (failFast) {
+            throw err;
+        }
+        console.warn(`${LOG_PREFIX} Failed to load Infisical secrets. Continuing without them.`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-infisical",
-  "version": "1.0.13",
+  "version": "2.0.0",
   "description": "CLI-free Infisical HTTP integration for NestJS",
   "license": "MIT",
   "main": "dist/index.js",
@@ -13,8 +13,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "axios": "^1.6.0",
-    "dotenv": "^16.4.0",
+    "dotenv": "^16.4.5",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
@@ -33,5 +32,13 @@
   },
   "devDependencies": {
     "@types/node": "^25.0.3"
-  }
+  },
+  "keywords": [
+    "nestjs",
+    "infisical",
+    "secrets",
+    "configuration",
+    "dotenv",
+    "http"
+  ]
 }

package/readme.md

@@ -1,216 +1,205 @@
 # nestjs-infisical
 
-nestjs-infisical is a **CLI-free**, **deterministic**, and **production-safe** Infisical integration for NestJS.
+CLI-free Infisical secrets loader for NestJS applications.
 
-It loads secrets **once at application startup** using the **Infisical HTTP API only** and injects them into `process.env`, making it fully compatible with `@nestjs/config`.
-
-This package is intentionally boring.
+This package loads secrets from Infisical **before** your NestJS application boots,
+injects them into `process.env`, and then hands control back to NestJS.
+It is intentionally boring, deterministic, and production-safe.
 
 ---
 
-## Why This Package Exists
+## Why this package exists
 
-Most Infisical integrations rely on the Infisical CLI, background agents, or runtime polling.
+Earlier versions attempted to integrate Infisical directly inside NestJS modules.
+While technically possible, this approach is **not deterministic** because:
 
-This package exists to provide:
+- NestJS does not guarantee global ordering of module side-effects
+- Async work inside modules can interleave with bootstrap
+- Debugging startup order becomes extremely difficult
 
-- No CLI dependency
-- No background processes
-- No runtime mutation
-- Deterministic startup behavior
-- Works in Docker, CI, and production
-- Pure HTTP API usage
+Secrets loading is **global, side-effectful, and order-sensitive**.
+The correct place for it is **before NestJS starts**.
 
-If you want secrets loaded **once at boot** and then forgotten, this is for you.
+This package now follows the same pattern used by:
+- AWS Parameter Store loaders
+- Vault integrations
+- Remote config systems
+- Feature flag bootstrappers
 
 ---
 
-## What This Package Does
+## Architecture (Current)
+
+Startup flow:
+
+1. Optional dotenv load
+2. Infisical HTTP API call
+3. Inject secrets into `process.env`
+4. NestJS application bootstrap
+5. `@nestjs/config` reads from `process.env`
 
-- Loads environment variables from `.env` using `dotenv` (optional)
-- Fetches secrets from Infisical via HTTP
-- Injects secrets into `process.env`
-- Allows `@nestjs/config` to consume them normally
-- Runs **only during application bootstrap**
+Diagram:
+
+dotenv → Infisical HTTP API → process.env → NestJS → ConfigModule
 
 ---
 
-## Load Order (IMPORTANT)
+## What changed from v1 to v2
 
-The load order is **strict and deterministic**:
+### Old approach (v1 – deprecated)
 
-```text
-dotenv (optional)
-   ↓
-Infisical HTTP API
-   ↓
-process.env
-   ↓
-@nestjs/config
-```
+- Dynamic NestJS module
+- Async logic inside providers
+- Relied on NestJS lifecycle ordering
+- Hard to debug, non-deterministic
 
-This guarantees compatibility with `ConfigModule.forRoot()`.
+### New approach (v2 – current)
+
+- Explicit async loader
+- Called from `main.ts`
+- Fully deterministic
+- No NestJS lifecycle coupling
+- Easier to reason about and debug
 
 ---
 
 ## Installation
 
-```bash
+```
 npm install nestjs-infisical
 ```
 
-Node.js **>= 18** is required.
+Node.js version requirement:
+
+- Node 18 or newer
 
 ---
 
-## Basic (Sync) Usage
+## Basic usage (recommended)
+
+### main.ts
 
 ```ts
-import { Module } from '@nestjs/common';
-import { InfisicalModule } from 'nestjs-infisical';
-
-@Module({
-  imports: [
-    InfisicalModule.forRoot({
-      baseUrl: 'https://app.infisical.com',
-      token: process.env.INFISICAL_TOKEN,
-      projectId: process.env.INFISICAL_PROJECT_ID,
-      environment: 'production',
-    }),
-  ],
-})
-export class AppModule {}
+import { loadInfisical } from 'nestjs-infisical';
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  await loadInfisical({
+    debug: true
+  });
+
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+}
+
+bootstrap();
 ```
 
-Secrets will be injected into `process.env` before the application finishes bootstrapping.
+That is all you need.
 
 ---
 
-## Async Usage (Recommended)
+## Configuration resolution order
 
-```ts
-import { Module } from '@nestjs/common';
-import { ConfigModule, ConfigService } from '@nestjs/config';
-import { InfisicalModule } from 'nestjs-infisical';
-
-@Module({
-  imports: [
-    ConfigModule.forRoot(),
-    InfisicalModule.forRootAsync({
-      imports: [ConfigModule],
-      inject: [ConfigService],
-      useFactory: (config: ConfigService) => ({
-        baseUrl: config.get('INFISICAL_BASE_URL'),
-        token: config.get('INFISICAL_TOKEN'),
-        projectId: config.get('INFISICAL_PROJECT_ID'),
-        environment: config.get('INFISICAL_ENVIRONMENT'),
-      }),
-    }),
-  ],
-})
-export class AppModule {}
-```
+Configuration is resolved in this order:
 
----
+1. dotenv (unless disabled)
+2. Explicit options passed to `loadInfisical`
+3. Environment variables (`process.env`)
 
-## Dotenv Support
+Required environment variables:
 
-This package uses the **official `dotenv` package directly**.
+- `INFISICAL_BASE_URL` (optional, defaults to Infisical Cloud)
+- `INFISICAL_TOKEN`
+- `INFISICAL_PROJECT_ID`
+- `INFISICAL_ENVIRONMENT`
 
-### Enable dotenv (default)
+---
 
-```ts
-InfisicalModule.forRoot({
-  dotenv: {
-    path: '.env.local',
-  },
-});
+## Zero-config usage
+
+If all configuration is present in `.env`:
+
+```
+INFISICAL_TOKEN=xxx
+INFISICAL_PROJECT_ID=yyy
+INFISICAL_ENVIRONMENT=dev
 ```
 
-### Disable dotenv
+You can simply call:
 
 ```ts
-InfisicalModule.forRoot({
-  dotenv: false,
-});
+await loadInfisical();
 ```
 
 ---
 
-## Configuration Options
+## Mixed configuration example
 
 ```ts
-interface InfisicalModuleOptions {
-  baseUrl?: string;
-  token?: string;
-  projectId?: string;
-  environment?: string;
-  dotenv?: DotenvConfigOptions | false;
-  override?: boolean;   // default: true
-  failFast?: boolean;   // default: true
-}
+await loadInfisical({
+  environment: 'production',
+  debug: true
+});
 ```
 
-### override
-
-- `true` → Infisical secrets overwrite existing environment variables
-- `false` → Existing environment variables are preserved
-
-### failFast
-
-- `true` → Application startup fails if Infisical API fails
-- `false` → Logs a warning and continues startup
+Missing values are automatically read from `process.env`.
 
 ---
 
-## Edge Case Behavior
+## Disable dotenv (Docker / Kubernetes)
 
-### No Infisical Config Provided
-
-Secrets are silently skipped. No logs, no errors.
+```ts
+await loadInfisical({
+  dotenv: false
+});
+```
 
-### Partial Infisical Config Provided
+---
 
-If only some Infisical values are provided:
+## Failure behavior
 
-```text
-[nestjs-infisical] Partial Infisical configuration detected. Secrets will not be loaded.
-```
+- `failFast: true` (default)
+  - Application crashes if Infisical fails
+- `failFast: false`
+  - Logs warning and continues without secrets
 
-Secrets are skipped intentionally.
+---
 
-### Infisical API Failure
+## What this package does NOT do
 
-- `failFast: true` → Throws error and aborts startup
-- `failFast: false` → Logs warning and continues
+- No Infisical CLI usage
+- No secret rotation
+- No background polling
+- No caching
+- No retries
+- No NestJS module mutation
+- No decorators
+- No health checks
 
 ---
 
-## Explicitly NOT Supported
+## Compatibility with @nestjs/config
 
-This package does **not**:
+Because secrets are loaded **before** NestJS starts,
+`@nestjs/config` works automatically without any integration.
 
-- Use the Infisical CLI
-- Add health checks
-- Rotate secrets
-- Poll or hot-reload secrets
-- Cache secrets
-- Add retries or backoff
-- Add decorators
-- Mutate NestJS internals
-- Run after bootstrap
+```ts
+ConfigModule.forRoot({
+  isGlobal: true
+});
+```
 
----
+All secrets are already present in `process.env`.
 
-## Design Philosophy
+---
 
-- Startup-only
-- Deterministic
-- Boring
-- Predictable
-- `process.env` is the only contract
+## Versioning note
 
-If you need dynamic secrets, rotation, or runtime behavior, use a different tool.
+This architecture change is released as **v2.x**.
+If you were using the old module-based integration,
+migrate by moving Infisical loading to `main.ts`.
 
 ---
 

package/dist/infisical.loader.d.ts

@@ -1,9 +0,0 @@
-export declare function loadInfisicalSecrets(options: {
-    baseUrl: string;
-    token: string;
-    projectId: string;
-    environment: string;
-    override: boolean;
-    failFast: boolean;
-    debug?: boolean;
-}): Promise<void>;

package/dist/infisical.loader.js

@@ -1,63 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadInfisicalSecrets = loadInfisicalSecrets;
-const LOG_PREFIX = '[nestjs-infisical]';
-function debugLog(enabled, message) {
-    if (enabled) {
-        console.log(`${LOG_PREFIX} ${message}`);
-    }
-}
-async function loadInfisicalSecrets(options) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5000); // 5s timeout
-    try {
-        debugLog(options.debug, 'Fetching secrets from Infisical');
-        debugLog(options.debug, `baseUrl=${options.baseUrl}, projectId=${options.projectId}, environment=${options.environment}`);
-        const url = new URL(`${options.baseUrl}/api/v3/secrets/raw`);
-        url.searchParams.set('projectId', options.projectId);
-        url.searchParams.set('environment', options.environment);
-        const response = await fetch(url.toString(), {
-            method: 'GET',
-            headers: {
-                Authorization: `Bearer ${options.token}`,
-                Accept: 'application/json',
-            },
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`Infisical API error ${response.status}: ${text}`);
-        }
-        const body = await response.json();
-        const secrets = body?.secrets ?? {};
-        debugLog(options.debug, `Fetched ${Object.keys(secrets).length} secrets from Infisical`);
-        debugLog(options.debug, `Secret keys fetched: ${Object.keys(secrets).join(', ')}`);
-        for (const [key, value] of Object.entries(secrets)) {
-            const exists = process.env[key] !== undefined;
-            if (options.override || !exists) {
-                debugLog(options.debug, exists
-                    ? `Overwriting env var: ${key}`
-                    : `Setting env var: ${key}`);
-                process.env[key] = value;
-            }
-            else {
-                debugLog(options.debug, `Skipping existing env var: ${key}`);
-            }
-        }
-    }
-    catch (err) {
-        console.error('Error while loading Infisical secrets', err);
-        if (err.name === 'AbortError') {
-            console.error(`${LOG_PREFIX} Infisical request timed out after 5s`);
-        }
-        else {
-            console.error(`${LOG_PREFIX} Error loading secrets from Infisical`, err);
-        }
-        if (options.failFast) {
-            throw err;
-        }
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}

package/dist/infisical.module.d.ts

@@ -1,6 +0,0 @@
-import { DynamicModule } from '@nestjs/common';
-import { InfisicalModuleAsyncOptions, InfisicalModuleOptions } from './infisical.types';
-export declare class InfisicalModule {
-    static forRoot(options?: InfisicalModuleOptions): DynamicModule;
-    static forRootAsync(options: InfisicalModuleAsyncOptions): DynamicModule;
-}

package/dist/infisical.module.js

@@ -1,99 +0,0 @@
-"use strict";
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InfisicalModule = void 0;
-const common_1 = require("@nestjs/common");
-const infisical_service_1 = require("./infisical.service");
-let InfisicalModule = (() => {
-    let _classDecorators = [(0, common_1.Module)({})];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    var InfisicalModule = _classThis = class {
-        static forRoot(options = {}) {
-            const resolved = {
-                baseUrl: options.baseUrl ?? process.env.INFISICAL_BASE_URL,
-                token: options.token ?? process.env.INFISICAL_TOKEN,
-                projectId: options.projectId ?? process.env.INFISICAL_PROJECT_ID,
-                environment: options.environment ?? process.env.INFISICAL_ENVIRONMENT,
-                dotenv: options.dotenv,
-                override: options.override ?? true,
-                failFast: options.failFast ?? true,
-            };
-            return {
-                module: InfisicalModule,
-                providers: [
-                    {
-                        provide: 'INFISICAL_BOOTSTRAP',
-                        useFactory: async () => {
-                            await (0, infisical_service_1.initializeInfisical)(resolved);
-                        },
-                    },
-                ],
-            };
-        }
-        static forRootAsync(options) {
-            return {
-                module: InfisicalModule,
-                imports: options.imports,
-                providers: [
-                    {
-                        provide: 'INFISICAL_BOOTSTRAP',
-                        inject: options.inject ?? [],
-                        useFactory: async (...args) => {
-                            const resolved = await options.useFactory(...args);
-                            await (0, infisical_service_1.initializeInfisical)(resolved);
-                        },
-                    },
-                ],
-            };
-        }
-    };
-    __setFunctionName(_classThis, "InfisicalModule");
-    (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-        InfisicalModule = _classThis = _classDescriptor.value;
-        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        __runInitializers(_classThis, _classExtraInitializers);
-    })();
-    return InfisicalModule = _classThis;
-})();
-exports.InfisicalModule = InfisicalModule;

package/dist/infisical.service.d.ts

@@ -1,2 +0,0 @@
-import { InfisicalModuleOptions } from './infisical.types';
-export declare function initializeInfisical(options: InfisicalModuleOptions): Promise<void>;

package/dist/infisical.service.js

@@ -1,45 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeInfisical = initializeInfisical;
-const infisical_loader_1 = require("./infisical.loader");
-const dotenv_1 = __importDefault(require("dotenv"));
-const LOG_PREFIX = '[nestjs-infisical]';
-function debugLog(enabled, message) {
-    if (enabled) {
-        console.log(`${LOG_PREFIX} ${message}`);
-    }
-}
-async function initializeInfisical(options) {
-    const { dotenv: dotenvOptions, baseUrl, token, projectId, environment, override = true, failFast = true, debug = false } = options;
-    if (dotenvOptions !== false) {
-        debugLog(debug, 'Loading dotenv configuration');
-        dotenv_1.default.config(dotenvOptions);
-    }
-    else {
-        debugLog(debug, 'Dotenv disabled');
-    }
-    const provided = [baseUrl, token, projectId, environment].filter(Boolean).length;
-    debugLog(debug, `Infisical config resolved: ${provided === 0 ? 'none' : provided === 4 ? 'complete' : 'partial'}`);
-    if (provided === 0) {
-        debugLog(debug, 'No Infisical configuration provided');
-        return;
-    }
-    if (provided !== 4) {
-        console.warn(`${LOG_PREFIX} Partial Infisical configuration detected. Secrets will not be loaded.`);
-        debugLog(debug, `baseUrl=${!!baseUrl}, token=${!!token}, projectId=${!!projectId}, environment=${!!environment}`);
-        return;
-    }
-    debugLog(debug, 'Loading Infisical secrets');
-    await (0, infisical_loader_1.loadInfisicalSecrets)({
-        baseUrl: baseUrl,
-        token: token,
-        projectId: projectId,
-        environment: environment,
-        override,
-        failFast,
-        debug
-    });
-}