@docker-harpoon/core 0.1.4 → 0.2.0

package/dist/testing/mocks.js

@@ -0,0 +1,224 @@
+/**
+ * Mock Implementations for Testing
+ *
+ * Provides mock implementations of Harpoon services for unit testing.
+ */
+import { Effect, Layer, Ref, PubSub, Stream, Duration, Option } from 'effect';
+import { DockerClient, } from '../services/DockerClient';
+import { DockerRateLimiter } from '../services/DockerRateLimiter';
+import { CircuitBreaker } from '../services/CircuitBreaker';
+import { ResourceTracker, } from '../services/ResourceTracker';
+import '../services/ReadinessCoordinator';
+import { HarpoonConfig } from '../services/HarpoonConfig';
+/**
+ * Create a mock Docker container.
+ */
+export const createMockContainer = (config) => ({
+    id: config.id,
+    start: () => Promise.resolve(),
+    stop: () => Promise.resolve(),
+    kill: () => Promise.resolve(),
+    remove: () => Promise.resolve(),
+    inspect: () => Promise.resolve({
+        Id: config.id,
+        Name: `/${config.name}`,
+        State: { Running: config.running ?? true },
+        NetworkSettings: { Networks: {} },
+    }),
+    logs: () => Promise.resolve(Buffer.from(config.logs ?? '')),
+    stats: () => Promise.resolve(config.stats ?? {
+        cpu_stats: {
+            cpu_usage: { total_usage: 1000000 },
+            system_cpu_usage: 100000000,
+            online_cpus: 4,
+        },
+        precpu_stats: {
+            cpu_usage: { total_usage: 900000 },
+            system_cpu_usage: 99000000,
+        },
+        memory_stats: {
+            usage: 1024 * 1024 * 100,
+            limit: 1024 * 1024 * 1024,
+        },
+        networks: {},
+    }),
+    exec: () => Promise.resolve({
+        start: () => Promise.resolve({}),
+        inspect: () => Promise.resolve({ ExitCode: 0 }),
+    }),
+});
+/**
+ * Create a mock Docker network.
+ */
+export const createMockNetwork = (id, name = 'mock-network') => ({
+    id,
+    inspect: () => Promise.resolve({ Id: id, Name: name }),
+    remove: () => Promise.resolve(),
+    connect: () => Promise.resolve(),
+    disconnect: () => Promise.resolve(),
+});
+/**
+ * Create a mock DockerClient layer with customizable behavior.
+ */
+export const createMockDockerClient = (overrides = {}) => Layer.succeed(DockerClient, {
+    _tag: 'DockerClient',
+    client: {},
+    ping: () => Effect.void,
+    version: () => Effect.succeed({
+        Version: '24.0.0',
+        ApiVersion: '1.43',
+        Os: 'linux',
+        Arch: 'amd64',
+    }),
+    listContainers: () => Effect.succeed([]),
+    getContainer: (id) => createMockContainer({ id, name: id }),
+    createContainer: (options) => Effect.succeed(createMockContainer({ id: `mock-${options.name}`, name: options.name })),
+    listNetworks: () => Effect.succeed([]),
+    getNetwork: (id) => createMockNetwork(id),
+    createNetwork: (options) => Effect.succeed(createMockNetwork(`mock-${options.Name}`, options.Name)),
+    getImage: (name) => ({
+        inspect: () => Promise.resolve({ Id: name }),
+        remove: () => Promise.resolve(),
+    }),
+    listImages: () => Effect.succeed([]),
+    pullImage: () => Effect.void,
+    ...overrides,
+});
+// ============ Mock RateLimiter ============
+/**
+ * Create a mock RateLimiter that doesn't limit.
+ */
+export const MockDockerRateLimiter = Layer.succeed(DockerRateLimiter, {
+    _tag: 'DockerRateLimiter',
+    withPermit: (effect) => effect,
+    withPermits: () => (effect) => effect,
+    available: () => Effect.succeed(Infinity),
+});
+// ============ Mock CircuitBreaker ============
+/**
+ * Create a mock CircuitBreaker that never opens.
+ */
+export const MockCircuitBreaker = Layer.succeed(CircuitBreaker, {
+    _tag: 'CircuitBreaker',
+    protect: (effect) => effect,
+    getState: () => Effect.succeed('Closed'),
+    reset: () => Effect.void,
+    getFailures: () => Effect.succeed(0),
+});
+// ============ Mock ResourceTracker ============
+/**
+ * Create a mock ResourceTracker that tracks in memory.
+ */
+export const createMockResourceTracker = () => Effect.gen(function* () {
+    const resources = yield* Ref.make(new Map());
+    return {
+        _tag: 'ResourceTracker',
+        register: (resource) => Ref.update(resources, (map) => {
+            const newMap = new Map(map);
+            newMap.set(resource.id, resource);
+            return newMap;
+        }),
+        unregister: (id) => Ref.update(resources, (map) => {
+            const newMap = new Map(map);
+            newMap.delete(id);
+            return newMap;
+        }),
+        get: (id) => Ref.get(resources).pipe(Effect.map((map) => Option.fromNullable(map.get(id)))),
+        getAll: () => Ref.get(resources).pipe(Effect.map((map) => [...map.values()])),
+        getByType: (type) => Ref.get(resources).pipe(Effect.map((map) => [...map.values()].filter((r) => r.type === type))),
+        count: () => Ref.get(resources).pipe(Effect.map((map) => map.size)),
+        destroyAll: () => Ref.set(resources, new Map()).pipe(Effect.asVoid),
+        destroyByType: (_type) => Effect.void,
+        clear: () => Ref.set(resources, new Map()),
+    };
+});
+export const MockResourceTracker = Layer.effect(ResourceTracker, createMockResourceTracker());
+// ============ Mock EventBus ============
+/**
+ * Create a mock EventBus that collects events.
+ */
+export const createMockEventBus = () => Effect.gen(function* () {
+    const events = yield* Ref.make([]);
+    const pubsub = yield* PubSub.unbounded();
+    const service = {
+        _tag: 'EventBus',
+        publish: (event) => Effect.all([
+            Ref.update(events, (arr) => [...arr, event]),
+            PubSub.publish(pubsub, event),
+        ]).pipe(Effect.map(() => true)),
+        subscribe: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue);
+        }),
+        subscribeContainers: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue).pipe(Stream.filter((e) => e._tag === 'ContainerEvent'));
+        }),
+        subscribeNetworks: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue).pipe(Stream.filter((e) => e._tag === 'NetworkEvent'));
+        }),
+        subscribeDatabases: () => Effect.gen(function* () {
+            const queue = yield* PubSub.subscribe(pubsub);
+            return Stream.fromQueue(queue).pipe(Stream.filter((e) => e._tag === 'DatabaseEvent'));
+        }),
+        subscriberCount: () => Effect.succeed(0),
+    };
+    return {
+        service,
+        getEvents: () => Ref.get(events),
+    };
+});
+// ============ Mock ReadinessCoordinator ============
+/**
+ * Create a mock ReadinessCoordinator.
+ */
+export const createMockReadinessCoordinator = (preReady = []) => Effect.gen(function* () {
+    const state = yield* Ref.make(new Map(preReady.map((id) => [id, true])));
+    return {
+        _tag: 'ReadinessCoordinator',
+        waitForReady: (containerId, _healthCheck, _checkFn, _options) => Ref.update(state, (map) => {
+            const newMap = new Map(map);
+            newMap.set(containerId, true);
+            return newMap;
+        }).pipe(Effect.asVoid),
+        isReady: (containerId) => Ref.get(state).pipe(Effect.map((map) => map.get(containerId) ?? false)),
+        markReady: (containerId) => Ref.update(state, (map) => {
+            const newMap = new Map(map);
+            newMap.set(containerId, true);
+            return newMap;
+        }),
+        markNotReady: (containerId) => Ref.update(state, (map) => {
+            const newMap = new Map(map);
+            newMap.set(containerId, false);
+            return newMap;
+        }),
+        untrack: (containerId) => Ref.update(state, (map) => {
+            const newMap = new Map(map);
+            newMap.delete(containerId);
+            return newMap;
+        }),
+        getAll: () => Ref.get(state).pipe(Effect.map((map) => [...map.entries()].map(([containerId, ready]) => ({
+            containerId,
+            ready,
+            timestamp: new Date(),
+        })))),
+    };
+});
+// ============ Mock HarpoonConfig ============
+/**
+ * Create a test configuration with fast timeouts.
+ */
+export const createMockHarpoonConfig = (overrides = {}) => Layer.succeed(HarpoonConfig, {
+    _tag: 'HarpoonConfig',
+    dockerSocket: undefined,
+    defaultTimeout: Duration.millis(5000),
+    cleanupTimeout: Duration.millis(1000),
+    logLevel: 'debug',
+    parallelLimit: 2,
+    retryAttempts: 1,
+    retryDelay: Duration.millis(100),
+    dockerStartupTimeout: Duration.millis(5000),
+    ...overrides,
+});
+export const MockHarpoonConfig = createMockHarpoonConfig();

package/dist/utils/process.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Cross-Runtime Process Utilities
+ *
+ * Provides process execution utilities that work with Node.js, Bun, and Deno.
+ * Uses Node.js child_process module which is compatible across all major runtimes.
+ */
+export interface SpawnResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * Convert a readable stream to a string.
+ */
+export declare function streamToString(stream: NodeJS.ReadableStream): Promise<string>;
+/**
+ * Execute a command and capture output.
+ * Works with Node.js, Bun, and Deno (via Node compat).
+ */
+export declare function execCommand(command: string, args: string[], options?: {
+    captureStdout?: boolean;
+    captureStderr?: boolean;
+}): Promise<SpawnResult>;
+//# sourceMappingURL=process.d.ts.map

package/dist/utils/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../src/utils/process.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAO7E;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,GAAE;IACP,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CACpB,GACL,OAAO,CAAC,WAAW,CAAC,CA6BtB"}

package/dist/utils/process.js

@@ -0,0 +1,49 @@
+/**
+ * Cross-Runtime Process Utilities
+ *
+ * Provides process execution utilities that work with Node.js, Bun, and Deno.
+ * Uses Node.js child_process module which is compatible across all major runtimes.
+ */
+import { spawn } from 'child_process';
+/**
+ * Convert a readable stream to a string.
+ */
+export function streamToString(stream) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        stream.on('error', reject);
+        stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    });
+}
+/**
+ * Execute a command and capture output.
+ * Works with Node.js, Bun, and Deno (via Node compat).
+ */
+export function execCommand(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(command, args, {
+            stdio: [
+                'ignore',
+                options.captureStdout ? 'pipe' : 'ignore',
+                options.captureStderr ? 'pipe' : 'ignore',
+            ],
+        });
+        let stdout = '';
+        let stderr = '';
+        if (proc.stdout) {
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+        }
+        if (proc.stderr) {
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+        }
+        proc.on('error', reject);
+        proc.on('close', (exitCode) => {
+            resolve({ exitCode: exitCode ?? 1, stdout, stderr });
+        });
+    });
+}

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@docker-harpoon/core",
-  "version": "0.1.4",
-  "license": "MIT",
+  "version": "0.2.0",
   "description": "Core Docker resource primitives and binding interface",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -10,11 +13,12 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
     }
   },
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "build": "tsgo",
     "typecheck": "tsgo --noEmit",
@@ -23,9 +27,9 @@
   "dependencies": {
     "dockerode": "^4.0.9",
     "effect": "^3.19.14",
-    "zod": "^4.3.5"
+    "zod": "^3.23.8"
   },
-  "peerDependencies": {
-    "bun": ">=1.0.0"
+  "devDependencies": {
+    "@effect/vitest": "^0.10.0"
   }
 }

package/dist/__tests__/bindings.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Bindings Integration Tests
- *
- * Dogfoods the binding system to verify:
- * - createEnvBinding helper
- * - Env var injection into containers
- * - Binding composition
- */
-export {};
-//# sourceMappingURL=bindings.test.d.ts.map

package/dist/__tests__/bindings.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bindings.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/bindings.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/dist/__tests__/bindings.test.js

@@ -1,128 +0,0 @@
-/**
- * Bindings Integration Tests
- *
- * Dogfoods the binding system to verify:
- * - createEnvBinding helper
- * - Env var injection into containers
- * - Binding composition
- */
-import { describe, test, expect, afterEach, beforeAll, setDefaultTimeout } from 'bun:test';
-import { Container, database, createEnvBinding, destroyAll } from '../index';
-import { buildTestImage, TEST_IMAGE } from './test-setup';
-setDefaultTimeout(30_000);
-const waitUntil = (fn, timeout = 5000) => {
-    return new Promise((resolve) => {
-        const interval = setInterval(() => {
-            if (fn()) {
-                clearInterval(interval);
-                resolve(true);
-            }
-        }, 100);
-    });
-};
-describe('Bindings', () => {
-    beforeAll(async () => {
-        await buildTestImage();
-    });
-    afterEach(async () => {
-        await destroyAll();
-    });
-    test('createEnvBinding creates a simple env binding', () => {
-        const binding = createEnvBinding('config', {
-            NODE_ENV: 'test',
-            LOG_LEVEL: 'debug',
-        });
-        expect(binding.type).toBe('config');
-        expect(binding.getEnv()).toEqual({
-            NODE_ENV: 'test',
-            LOG_LEVEL: 'debug',
-        });
-    });
-    test('container receives env vars from bindings', async () => {
-        const configBinding = createEnvBinding('config', {
-            APP_NAME: 'test-app',
-            APP_VERSION: '1.0.0',
-        });
-        const container = await Container('test-binding-env', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-            bindings: {
-                config: configBinding,
-            },
-        });
-        await waitUntil(() => !!container.getIp('test-binding-env'), 5000);
-        const result = await container.exec([
-            'sh',
-            '-c',
-            'echo "$APP_NAME:$APP_VERSION"',
-        ]);
-        expect(result.stdout.trim()).toBe('test-app:1.0.0');
-        await container.destroy();
-    });
-    test('multiple bindings merge env vars', async () => {
-        const binding1 = createEnvBinding('env1', {
-            VAR_A: 'a',
-            VAR_B: 'b',
-        });
-        const binding2 = createEnvBinding('env2', {
-            VAR_C: 'c',
-            VAR_D: 'd',
-        });
-        const container = await Container('test-multi-binding', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-            bindings: {
-                first: binding1,
-                second: binding2,
-            },
-        });
-        await waitUntil(() => !!container.getIp('test-multi-binding'), 5000);
-        const result = await container.exec([
-            'sh',
-            '-c',
-            'echo "$VAR_A$VAR_B$VAR_C$VAR_D"',
-        ]);
-        expect(result.stdout.trim()).toBe('abcd');
-        await container.destroy();
-    });
-    test('explicit env takes precedence over bindings', async () => {
-        const binding = createEnvBinding('config', {
-            MY_VAR: 'from-binding',
-        });
-        const container = await Container('test-env-precedence', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-            bindings: {
-                config: binding,
-            },
-            env: {
-                MY_VAR: 'from-explicit',
-            },
-        });
-        await waitUntil(() => !!container.getIp('test-env-precedence'), 5000);
-        const result = await container.exec(['sh', '-c', 'echo "$MY_VAR"']);
-        expect(result.stdout.trim()).toBe('from-explicit');
-        await container.destroy();
-    });
-    test('database can be used as binding resource', async () => {
-        const db = await database('test-db-binding', {
-            image: 'redis:7-alpine',
-            hostPort: 16390,
-        });
-        const dbBinding = createEnvBinding('database', {
-            REDIS_URL: db.connectionString,
-        });
-        const container = await Container('test-db-consumer', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-            bindings: {
-                db: dbBinding,
-            },
-        });
-        await waitUntil(() => !!container.getIp('test-db-consumer'), 5000);
-        const result = await container.exec(['sh', '-c', 'echo "$REDIS_URL"']);
-        expect(result.stdout.trim()).toBe('redis://localhost:16390');
-        await container.destroy();
-        await db.destroy();
-    });
-});

package/dist/__tests__/container.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * Container Resource Integration Tests
- *
- * Dogfoods the Container resource to verify:
- * - Creation with network binding
- * - waitForLog functionality
- * - exec command execution
- * - stats retrieval
- * - Lifecycle (stop, destroy)
- */
-export {};
-//# sourceMappingURL=container.test.d.ts.map

package/dist/__tests__/container.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"container.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/container.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/__tests__/container.test.js

@@ -1,136 +0,0 @@
-/**
- * Container Resource Integration Tests
- *
- * Dogfoods the Container resource to verify:
- * - Creation with network binding
- * - waitForLog functionality
- * - exec command execution
- * - stats retrieval
- * - Lifecycle (stop, destroy)
- */
-import { describe, test, expect, afterEach, beforeAll, setDefaultTimeout } from 'bun:test';
-import { Network, Container, destroyAll } from '../index';
-import { buildTestImage, TEST_IMAGE } from './test-setup';
-setDefaultTimeout(30_000);
-describe('Container', () => {
-    beforeAll(async () => {
-        await buildTestImage();
-    });
-    afterEach(async () => {
-        await destroyAll();
-    });
-    test('creates a container with basic config', async () => {
-        const container = await Container('test-container-basic', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-        });
-        expect(container.id).toBeDefined();
-        expect(container.name).toBe('test-container-basic');
-        await container.destroy();
-    });
-    test('creates a container attached to a network', async () => {
-        const network = await Network('test-container-net');
-        const container = await Container('test-container-networked', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-            networks: [network],
-        });
-        expect(container.id).toBeDefined();
-        const ip = await container.getIp('test-container-net');
-        expect(ip).toBeDefined();
-        await container.destroy();
-        await network.destroy();
-    });
-    test('exec runs commands inside container', async () => {
-        const container = await Container('test-container-exec', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-        });
-        await new Promise((r) => setTimeout(r, 500));
-        const result = await container.exec(['echo', 'hello world']);
-        expect(result.exitCode).toBe(0);
-        expect(result.stdout.trim()).toBe('hello world');
-        expect(result.durationMs).toBeGreaterThan(0);
-        await container.destroy();
-    });
-    test('stats returns container resource statistics', async () => {
-        const container = await Container('test-container-stats', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-        });
-        await new Promise((r) => setTimeout(r, 500));
-        const stats = await container.stats();
-        expect(stats.cpu).toBeDefined();
-        expect(stats.cpu.cores).toBeGreaterThan(0);
-        expect(stats.memory).toBeDefined();
-        expect(stats.memory.limit).toBeGreaterThan(0);
-        expect(stats.network).toBeDefined();
-        expect(stats.containerId).toBe(container.id);
-        await container.destroy();
-    });
-    test('waitForLog detects log patterns', async () => {
-        const container = await Container('test-container-logs', {
-            image: TEST_IMAGE,
-            cmd: ['sh', '-c', 'echo "Server started successfully" && sleep 30'],
-        });
-        await container.waitForLog('Server started', 5000);
-        expect(true).toBe(true);
-        await container.destroy();
-    });
-    test('stop gracefully shuts down container', async () => {
-        const container = await Container('test-container-stop', {
-            image: TEST_IMAGE,
-            cmd: ['sh', '-c', 'trap "exit 0" TERM; while true; do sleep 1; done'],
-        });
-        await new Promise((r) => setTimeout(r, 500));
-        const metadata = await container.stop('SIGTERM', 10000);
-        expect(metadata.signal).toBe('SIGTERM');
-        expect(metadata.signalCount).toBeGreaterThan(0);
-        expect(metadata.timeTakenMs).toBeGreaterThan(0);
-        await container.destroy();
-    });
-    test('supports environment variables', async () => {
-        const container = await Container('test-container-env', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-            env: {
-                MY_VAR: 'hello',
-                ANOTHER_VAR: 'world',
-            },
-        });
-        await new Promise((r) => setTimeout(r, 500));
-        const result = await container.exec([
-            'sh',
-            '-c',
-            'echo $MY_VAR $ANOTHER_VAR',
-        ]);
-        expect(result.stdout.trim()).toBe('hello world');
-        await container.destroy();
-    });
-    test('supports port mappings', async () => {
-        const container = await Container('test-container-ports', {
-            image: TEST_IMAGE,
-            cmd: ['sleep', '30'],
-            ports: [{ internal: 8080, external: 18080 }],
-        });
-        expect(container.id).toBeDefined();
-        await container.destroy();
-    });
-    test('streamLogs terminates without follow option', async () => {
-        const container = await Container('test-logs-terminate', {
-            image: TEST_IMAGE,
-            cmd: ['sh', '-c', 'echo "line1" && echo "line2" && echo "line3" && sleep 30'],
-        });
-        await container.waitForLog('line3', 5000);
-        const lines = [];
-        const logStream = await container.streamLogs({ tail: 3 });
-        for await (const line of logStream) {
-            lines.push(line.message);
-        }
-        // Loop should exit naturally
-        expect(lines).toContain('line1');
-        expect(lines).toContain('line2');
-        expect(lines).toContain('line3');
-        await container.destroy();
-    });
-});

package/dist/__tests__/database.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Database Helper Integration Tests
- *
- * Dogfoods the database helper to verify:
- * - Connection string generation
- * - Port mapping
- * - Database-specific defaults
- */
-export {};
-//# sourceMappingURL=database.test.d.ts.map

package/dist/__tests__/database.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"database.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/database.test.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}