@zintrust/cloudflare-containers-proxy 0.1.43 → 0.1.51

package/dist/index.d.ts

@@ -16,6 +16,25 @@ export type ZintrustContainersProxyEnv = {
     APP_NAME?: string;
     APP_KEY?: string;
     CSRF_SKIP_PATHS?: string;
+    HOST?: string;
+    DB_HOST?: string;
+    DB_PORT?: string;
+    DB_DATABASE?: string;
+    DB_USERNAME?: string;
+    DB_PASSWORD?: string;
+    DB_PORT_POSTGRESQL?: string;
+    DB_DATABASE_POSTGRESQL?: string;
+    DB_USERNAME_POSTGRESQL?: string;
+    DB_PASSWORD_POSTGRESQL?: string;
+    DB_HOST_MSSQL?: string;
+    DB_PORT_MSSQL?: string;
+    DB_DATABASE_MSSQL?: string;
+    DB_USERNAME_MSSQL?: string;
+    DB_PASSWORD_MSSQL?: string;
+    REDIS_HOST?: string;
+    REDIS_PORT?: string;
+    REDIS_PASSWORD?: string;
+    REDIS_DB?: string;
     ZT_ZIN_BIN?: string;
     MYSQL_PROXY_KEY_ID?: string;
     MYSQL_PROXY_SECRET?: string;

package/dist/index.js

@@ -1,4 +1,5 @@
 import { Container } from '@cloudflare/containers';
+import { ErrorFactory, Logger } from '@zintrust/core';
 const getContainerEnv = (container) => {
     return container.env;
 };
@@ -29,6 +30,13 @@ const createProxyEntrypoint = (env, command, port) => {
     return ['node', resolveZinBin(env), command, '--host', '0.0.0.0', '--port', String(port)];
 };
 const createMySqlProxyEnvVars = (env) => {
+    const dbHost = toStringEnv(env.MYSQL_DB_HOST, '') ||
+        toStringEnv(env.DB_HOST, '') ||
+        toStringEnv(env.HOST, 'host.docker.internal');
+    const dbPort = toStringEnv(env.MYSQL_DB_PORT, '') || toStringEnv(env.DB_PORT, '3306');
+    const dbName = toStringEnv(env.MYSQL_DB_DATABASE, '') || toStringEnv(env.DB_DATABASE, 'zintrust');
+    const dbUser = toStringEnv(env.MYSQL_DB_USERNAME, '') || toStringEnv(env.DB_USERNAME, 'root');
+    const dbPass = toStringEnv(env.MYSQL_DB_PASSWORD, '') || toStringEnv(env.DB_PASSWORD, '');
     return {
         ...createCommonProxyEnvVars(env),
         MYSQL_PROXY_REQUIRE_SIGNING: 'true',
@@ -36,19 +44,28 @@ const createMySqlProxyEnvVars = (env) => {
         MYSQL_PROXY_SECRET: toStringEnv(env.MYSQL_PROXY_SECRET, ''),
         MYSQL_PROXY_SIGNING_WINDOW_MS: toStringEnv(env.MYSQL_PROXY_SIGNING_WINDOW_MS, '60000'),
         MYSQL_PROXY_POOL_LIMIT: toStringEnv(env.MYSQL_PROXY_POOL_LIMIT, '100'),
-        MYSQL_DB_HOST: toStringEnv(env.MYSQL_DB_HOST, ''),
-        MYSQL_DB_PORT: toStringEnv(env.MYSQL_DB_PORT, '3306'),
-        MYSQL_DB_DATABASE: toStringEnv(env.MYSQL_DB_DATABASE, 'zintrust'),
-        MYSQL_DB_USERNAME: toStringEnv(env.MYSQL_DB_USERNAME, 'zintrust'),
-        MYSQL_DB_PASSWORD: toStringEnv(env.MYSQL_DB_PASSWORD, ''),
-        DB_HOST: toStringEnv(env.MYSQL_DB_HOST, ''),
-        DB_PORT: toStringEnv(env.MYSQL_DB_PORT, '3306'),
-        DB_DATABASE: toStringEnv(env.MYSQL_DB_DATABASE, 'zintrust'),
-        DB_USERNAME: toStringEnv(env.MYSQL_DB_USERNAME, 'zintrust'),
-        DB_PASSWORD: toStringEnv(env.MYSQL_DB_PASSWORD, ''),
+        MYSQL_DB_HOST: dbHost,
+        MYSQL_DB_PORT: dbPort,
+        MYSQL_DB_DATABASE: dbName,
+        MYSQL_DB_USERNAME: dbUser,
+        MYSQL_DB_PASSWORD: dbPass,
+        DB_HOST: dbHost,
+        DB_PORT: dbPort,
+        DB_DATABASE: dbName,
+        DB_USERNAME: dbUser,
+        DB_PASSWORD: dbPass,
     };
 };
 const createPostgresProxyEnvVars = (env) => {
+    const dbHost = toStringEnv(env.POSTGRES_DB_HOST, '') ||
+        toStringEnv(env.DB_HOST, '') ||
+        toStringEnv(env.HOST, 'host.docker.internal');
+    const dbPort = toStringEnv(env.POSTGRES_DB_PORT, '') || toStringEnv(env.DB_PORT_POSTGRESQL, '5432');
+    const dbName = toStringEnv(env.POSTGRES_DB_DATABASE, '') ||
+        toStringEnv(env.DB_DATABASE_POSTGRESQL, 'postgres');
+    const dbUser = toStringEnv(env.POSTGRES_DB_USERNAME, '') ||
+        toStringEnv(env.DB_USERNAME_POSTGRESQL, 'postgres');
+    const dbPass = toStringEnv(env.POSTGRES_DB_PASSWORD, '') || toStringEnv(env.DB_PASSWORD_POSTGRESQL, '');
     return {
         ...createCommonProxyEnvVars(env),
         POSTGRES_PROXY_REQUIRE_SIGNING: 'true',
@@ -56,28 +73,34 @@ const createPostgresProxyEnvVars = (env) => {
         POSTGRES_PROXY_SECRET: toStringEnv(env.POSTGRES_PROXY_SECRET, ''),
         POSTGRES_PROXY_SIGNING_WINDOW_MS: toStringEnv(env.POSTGRES_PROXY_SIGNING_WINDOW_MS, '60000'),
         POSTGRES_PROXY_POOL_LIMIT: toStringEnv(env.POSTGRES_PROXY_POOL_LIMIT, '100'),
-        DB_HOST: toStringEnv(env.POSTGRES_DB_HOST, ''),
-        DB_PORT_POSTGRESQL: toStringEnv(env.POSTGRES_DB_PORT, '5432'),
-        DB_DATABASE_POSTGRESQL: toStringEnv(env.POSTGRES_DB_DATABASE, 'postgres'),
-        DB_USERNAME_POSTGRESQL: toStringEnv(env.POSTGRES_DB_USERNAME, 'postgres'),
-        DB_PASSWORD_POSTGRESQL: toStringEnv(env.POSTGRES_DB_PASSWORD, ''),
+        DB_HOST: dbHost,
+        DB_PORT_POSTGRESQL: dbPort,
+        DB_DATABASE_POSTGRESQL: dbName,
+        DB_USERNAME_POSTGRESQL: dbUser,
+        DB_PASSWORD_POSTGRESQL: dbPass,
     };
 };
 const createRedisProxyEnvVars = (env) => {
+    const targetHost = toStringEnv(env.REDIS_PROXY_TARGET_HOST, '') ||
+        toStringEnv(env.REDIS_HOST, '') ||
+        toStringEnv(env.HOST, 'host.docker.internal');
+    const targetPort = toStringEnv(env.REDIS_PROXY_TARGET_PORT, '') || toStringEnv(env.REDIS_PORT, '6379');
+    const targetPassword = toStringEnv(env.REDIS_PROXY_TARGET_PASSWORD, '') || toStringEnv(env.REDIS_PASSWORD, '');
+    const targetDb = toStringEnv(env.REDIS_PROXY_TARGET_DB, '') || toStringEnv(env.REDIS_DB, '0');
     return {
         ...createCommonProxyEnvVars(env),
         REDIS_PROXY_REQUIRE_SIGNING: 'true',
         REDIS_PROXY_KEY_ID: toStringEnv(env.REDIS_PROXY_KEY_ID, ''),
         REDIS_PROXY_SECRET: toStringEnv(env.REDIS_PROXY_SECRET, ''),
         REDIS_PROXY_SIGNING_WINDOW_MS: toStringEnv(env.REDIS_PROXY_SIGNING_WINDOW_MS, '60000'),
-        REDIS_PROXY_TARGET_HOST: toStringEnv(env.REDIS_PROXY_TARGET_HOST, ''),
-        REDIS_PROXY_TARGET_PORT: toStringEnv(env.REDIS_PROXY_TARGET_PORT, '6379'),
-        REDIS_PROXY_TARGET_PASSWORD: toStringEnv(env.REDIS_PROXY_TARGET_PASSWORD, ''),
-        REDIS_PROXY_TARGET_DB: toStringEnv(env.REDIS_PROXY_TARGET_DB, '0'),
-        REDIS_HOST: toStringEnv(env.REDIS_PROXY_TARGET_HOST, ''),
-        REDIS_PORT: toStringEnv(env.REDIS_PROXY_TARGET_PORT, '6379'),
-        REDIS_PASSWORD: toStringEnv(env.REDIS_PROXY_TARGET_PASSWORD, ''),
-        REDIS_DB: toStringEnv(env.REDIS_PROXY_TARGET_DB, '0'),
+        REDIS_PROXY_TARGET_HOST: targetHost,
+        REDIS_PROXY_TARGET_PORT: targetPort,
+        REDIS_PROXY_TARGET_PASSWORD: targetPassword,
+        REDIS_PROXY_TARGET_DB: targetDb,
+        REDIS_HOST: targetHost,
+        REDIS_PORT: targetPort,
+        REDIS_PASSWORD: targetPassword,
+        REDIS_DB: targetDb,
     };
 };
 const createMongoDbProxyEnvVars = (env) => {
@@ -87,11 +110,19 @@ const createMongoDbProxyEnvVars = (env) => {
         MONGODB_PROXY_KEY_ID: toStringEnv(env.MONGODB_PROXY_KEY_ID, ''),
         MONGODB_PROXY_SECRET: toStringEnv(env.MONGODB_PROXY_SECRET, ''),
         MONGODB_PROXY_SIGNING_WINDOW_MS: toStringEnv(env.MONGODB_PROXY_SIGNING_WINDOW_MS, '60000'),
-        MONGO_URI: toStringEnv(env.MONGODB_PROXY_TARGET_URI, ''),
+        MONGO_URI: toStringEnv(env.MONGODB_PROXY_TARGET_URI, 'mongodb://host.docker.internal:27017'),
         MONGO_DB: toStringEnv(env.MONGODB_PROXY_TARGET_DB, 'zintrust'),
     };
 };
 const createSqlServerProxyEnvVars = (env) => {
+    const dbHost = toStringEnv(env.SQLSERVER_DB_HOST, '') ||
+        toStringEnv(env.DB_HOST_MSSQL, '') ||
+        toStringEnv(env.DB_HOST, '') ||
+        toStringEnv(env.HOST, 'host.docker.internal');
+    const dbPort = toStringEnv(env.SQLSERVER_DB_PORT, '') || toStringEnv(env.DB_PORT_MSSQL, '1433');
+    const dbName = toStringEnv(env.SQLSERVER_DB_DATABASE, '') || toStringEnv(env.DB_DATABASE_MSSQL, 'zintrust');
+    const dbUser = toStringEnv(env.SQLSERVER_DB_USERNAME, '') || toStringEnv(env.DB_USERNAME_MSSQL, 'sa');
+    const dbPass = toStringEnv(env.SQLSERVER_DB_PASSWORD, '') || toStringEnv(env.DB_PASSWORD_MSSQL, '');
     return {
         ...createCommonProxyEnvVars(env),
         SQLSERVER_PROXY_REQUIRE_SIGNING: 'true',
@@ -99,11 +130,11 @@ const createSqlServerProxyEnvVars = (env) => {
         SQLSERVER_PROXY_SECRET: toStringEnv(env.SQLSERVER_PROXY_SECRET, ''),
         SQLSERVER_PROXY_SIGNING_WINDOW_MS: toStringEnv(env.SQLSERVER_PROXY_SIGNING_WINDOW_MS, '60000'),
         SQLSERVER_PROXY_POOL_LIMIT: toStringEnv(env.SQLSERVER_PROXY_POOL_LIMIT, '100'),
-        DB_HOST_MSSQL: toStringEnv(env.SQLSERVER_DB_HOST, ''),
-        DB_PORT_MSSQL: toStringEnv(env.SQLSERVER_DB_PORT, '1433'),
-        DB_DATABASE_MSSQL: toStringEnv(env.SQLSERVER_DB_DATABASE, 'zintrust'),
-        DB_USERNAME_MSSQL: toStringEnv(env.SQLSERVER_DB_USERNAME, 'sa'),
-        DB_PASSWORD_MSSQL: toStringEnv(env.SQLSERVER_DB_PASSWORD, ''),
+        DB_HOST_MSSQL: dbHost,
+        DB_PORT_MSSQL: dbPort,
+        DB_DATABASE_MSSQL: dbName,
+        DB_USERNAME_MSSQL: dbUser,
+        DB_PASSWORD_MSSQL: dbPass,
     };
 };
 const createSmtpProxyEnvVars = (env) => {
@@ -140,7 +171,9 @@ const ensureContainerStarted = async (container, port, start) => {
 export class ZintrustMySqlProxyContainer extends Container {
     defaultPort = 8789;
     sleepAfter = '10m';
-    pingEndpoint = '/health';
+    // Keep this lightweight: the proxy root path responds quickly (401 without
+    // signing headers) and does not depend on DB connectivity like /health.
+    pingEndpoint = 'containerstarthealthcheck';
     async fetch(request) {
         const env = getContainerEnv(this);
         await ensureContainerStarted(this, 8789, {
@@ -153,7 +186,7 @@ export class ZintrustMySqlProxyContainer extends Container {
 export class ZintrustPostgresProxyContainer extends Container {
     defaultPort = 8790;
     sleepAfter = '10m';
-    pingEndpoint = '/health';
+    pingEndpoint = 'containerstarthealthcheck';
     async fetch(request) {
         const env = getContainerEnv(this);
         await ensureContainerStarted(this, 8790, {
@@ -166,7 +199,7 @@ export class ZintrustPostgresProxyContainer extends Container {
 export class ZintrustRedisProxyContainer extends Container {
     defaultPort = 8791;
     sleepAfter = '10m';
-    pingEndpoint = '/health';
+    pingEndpoint = 'containerstarthealthcheck';
     async fetch(request) {
         const env = getContainerEnv(this);
         await ensureContainerStarted(this, 8791, {
@@ -179,7 +212,7 @@ export class ZintrustRedisProxyContainer extends Container {
 export class ZintrustMongoDbProxyContainer extends Container {
     defaultPort = 8792;
     sleepAfter = '10m';
-    pingEndpoint = '/health';
+    pingEndpoint = 'containerstarthealthcheck';
     async fetch(request) {
         const env = getContainerEnv(this);
         await ensureContainerStarted(this, 8792, {
@@ -192,7 +225,7 @@ export class ZintrustMongoDbProxyContainer extends Container {
 export class ZintrustSqlServerProxyContainer extends Container {
     defaultPort = 8793;
     sleepAfter = '10m';
-    pingEndpoint = '/health';
+    pingEndpoint = 'containerstarthealthcheck';
     async fetch(request) {
         const env = getContainerEnv(this);
         await ensureContainerStarted(this, 8793, {
@@ -205,7 +238,7 @@ export class ZintrustSqlServerProxyContainer extends Container {
 export class ZintrustSmtpProxyContainer extends Container {
     defaultPort = 8794;
     sleepAfter = '10m';
-    pingEndpoint = '/health';
+    pingEndpoint = 'containerstarthealthcheck';
     async fetch(request) {
         const env = getContainerEnv(this);
         await ensureContainerStarted(this, 8794, {
@@ -238,6 +271,79 @@ const rewritePrefix = (request, prefix) => {
     return new Request(url.toString(), request);
 };
 const CONTAINER_INSTANCE_NAME = 'cf-singleton-container';
+const CONTAINER_RETRY_ATTEMPTS = 20;
+const CONTAINER_RETRY_DELAY_MS = 500;
+const isContainerNotReadyMessage = (value) => {
+    return (value.includes('Monitor failed to find container') ||
+        value.includes('container port not found') ||
+        value.includes('Connection refused'));
+};
+const responseIndicatesContainerNotReady = async (response) => {
+    if (!response)
+        return false;
+    if (response.status !== 500)
+        return false;
+    try {
+        const text = await response.clone().text();
+        return isContainerNotReadyMessage(text);
+    }
+    catch {
+        return false;
+    }
+};
+const errorIndicatesContainerNotReady = (error) => {
+    const msg = error instanceof Error ? error.message : String(error);
+    return isContainerNotReadyMessage(msg);
+};
+const sleepMs = async (ms) => {
+    if (typeof AbortSignal === 'undefined' || typeof AbortSignal.timeout !== 'function') {
+        throw ErrorFactory.createValidationError('Container retry sleep requires AbortSignal.timeout() support in this runtime');
+    }
+    const signal = AbortSignal.timeout(ms);
+    await new Promise((resolve) => {
+        if (signal.aborted) {
+            resolve();
+            return;
+        }
+        signal.addEventListener('abort', () => resolve(), { once: true });
+    });
+};
+const createContainerNotReadyResponse = (_message) => {
+    return createJson({
+        error: 'container_not_ready',
+        service: 'zintrust-containers-proxy',
+        message: 'Container is starting. Retry shortly.',
+    }, { status: 503 });
+};
+const fetchWithContainerRetry = async (stub, request, attempt = 1) => {
+    try {
+        const requestClone = request.clone();
+        const response = await stub.fetch(requestClone);
+        const notReady = await responseIndicatesContainerNotReady(response);
+        if (!notReady)
+            return response;
+        if (attempt >= CONTAINER_RETRY_ATTEMPTS) {
+            return createContainerNotReadyResponse('Container monitor not ready (max retries reached).');
+        }
+        Logger.warn('Container not ready; retrying', { attempt, max: CONTAINER_RETRY_ATTEMPTS });
+        await sleepMs(CONTAINER_RETRY_DELAY_MS);
+        return fetchWithContainerRetry(stub, request, attempt + 1);
+    }
+    catch (error) {
+        if (!errorIndicatesContainerNotReady(error))
+            throw error;
+        if (attempt >= CONTAINER_RETRY_ATTEMPTS) {
+            return createContainerNotReadyResponse(String(error));
+        }
+        Logger.warn('Container connection error; retrying', {
+            attempt,
+            max: CONTAINER_RETRY_ATTEMPTS,
+            error: String(error),
+        });
+        await sleepMs(CONTAINER_RETRY_DELAY_MS);
+        return fetchWithContainerRetry(stub, request, attempt + 1);
+    }
+};
 const ROUTES = Object.freeze({
     mysql: { binding: 'ZT_PROXY_MYSQL', prefix: '/mysql' },
     postgres: { binding: 'ZT_PROXY_POSTGRES', prefix: '/postgres' },
@@ -266,7 +372,16 @@ export default {
             return createJson({ error: 'not_found', message: 'Unknown proxy route' }, { status: 404 });
         }
         const namespace = env[def.binding];
+        if (!namespace || typeof namespace.getByName !== 'function') {
+            return createJson({
+                error: 'missing_binding',
+                service: 'zintrust-containers-proxy',
+                binding: def.binding,
+                message: 'Durable Object binding is missing. Ensure your Wrangler config defines durable_objects bindings for ZT_PROXY_* (and containers/migrations) for the selected --env.',
+            }, { status: 500 });
+        }
         const stub = namespace.getByName(CONTAINER_INSTANCE_NAME);
-        return stub.fetch(rewritePrefix(request, def.prefix));
+        const nextRequest = rewritePrefix(request, def.prefix);
+        return fetchWithContainerRetry(stub, nextRequest);
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/cloudflare-containers-proxy",
-  "version": "0.1.43",
+  "version": "0.1.51",
   "private": false,
   "type": "module",
   "exports": {
@@ -19,7 +19,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@zintrust/core": "^0.1.43"
+    "@zintrust/core": "^0.1.51"
   },
   "dependencies": {
     "@cloudflare/containers": "^0.1.0",

package/dist/build-manifest.json

@@ -1,36 +0,0 @@
-{
-  "name": "@zintrust/cloudflare-containers-proxy",
-  "version": "0.1.43",
-  "buildDate": "2026-02-19T18:46:20.595Z",
-  "buildEnvironment": {
-    "node": "v20.20.0",
-    "platform": "linux",
-    "arch": "x64"
-  },
-  "git": {
-    "commit": "d42fc0e",
-    "branch": "master"
-  },
-  "package": {
-    "engines": {
-      "node": ">=20.0.0"
-    },
-    "dependencies": [
-      "@cloudflare/containers",
-      "@cloudflare/workers-types"
-    ],
-    "peerDependencies": [
-      "@zintrust/core"
-    ]
-  },
-  "files": {
-    "index.d.ts": {
-      "size": 3701,
-      "sha256": "0f7335c84e3f52ee46fa680b635f383e607e64af93338701934105234be3ce18"
-    },
-    "index.js": {
-      "size": 12198,
-      "sha256": "00696df76d78232e337eb112ff58b791daf52ecd8d01b62b25020691cd79d772"
-    }
-  }
-}