@celerity-sdk/testing 0.8.0

package/dist/index.cjs

@@ -0,0 +1,1070 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TestApp: () => TestApp,
+  TestHttpClient: () => TestHttpClient,
+  TestRequest: () => TestRequest,
+  TestWsClient: () => TestWsClient,
+  createMocksForTokens: () => createMocksForTokens,
+  createResourceMock: () => createResourceMock,
+  createTestApp: () => createTestApp,
+  createTestClient: () => createTestClient,
+  createTestWsClient: () => createTestWsClient,
+  discoverResourceTokens: () => discoverResourceTokens,
+  generateTestToken: () => generateTestToken,
+  loadBlueprintResources: () => loadBlueprintResources,
+  loadWebSocketConfig: () => loadWebSocketConfig,
+  mockConsumerEvent: () => import_core3.mockConsumerEvent,
+  mockRequest: () => import_core3.mockRequest,
+  mockScheduleEvent: () => import_core3.mockScheduleEvent,
+  mockWebSocketMessage: () => import_core3.mockWebSocketMessage,
+  waitFor: () => waitFor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/test-app.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+var import_core2 = require("@celerity-sdk/core");
+
+// src/discovery.ts
+var import_reflect_metadata = require("reflect-metadata");
+var import_common = require("@celerity-sdk/common");
+var import_core = require("@celerity-sdk/core");
+function discoverResourceTokens(rootModule) {
+  const graph = (0, import_core.buildModuleGraph)(rootModule);
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const [, node] of graph) {
+    const classes = [
+      ...node.controllers,
+      ...node.guards.filter((g) => typeof g === "function")
+    ];
+    for (const provider of node.providers) {
+      if (typeof provider === "function") {
+        classes.push(provider);
+      } else if ("useClass" in provider) {
+        classes.push(provider.useClass);
+      }
+    }
+    for (const cls of classes) {
+      const depTokens = (0, import_core.getClassDependencyTokens)(cls);
+      for (const dep of depTokens) {
+        if (typeof dep !== "symbol") continue;
+        if (!(0, import_common.isRuntimeProvidedToken)(dep)) continue;
+        if (seen.has(dep)) continue;
+        seen.add(dep);
+        const parsed = parseResourceToken(dep);
+        if (parsed) {
+          result.push(parsed);
+        }
+      }
+    }
+  }
+  return result;
+}
+__name(discoverResourceTokens, "discoverResourceTokens");
+function parseResourceToken(token) {
+  const desc = token.description;
+  if (!desc) return null;
+  const parts = desc.split(":");
+  if (parts.length < 3 || parts[0] !== "celerity") return null;
+  return {
+    token,
+    type: parts[1],
+    name: parts.slice(2).join(":")
+  };
+}
+__name(parseResourceToken, "parseResourceToken");
+
+// src/blueprint.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_js_yaml = __toESM(require("js-yaml"), 1);
+var import_strip_json_comments = __toESM(require("strip-json-comments"), 1);
+function loadBlueprintResources(blueprintPath) {
+  const path = blueprintPath ?? findBlueprintPath();
+  if (!path) return /* @__PURE__ */ new Map();
+  const bp = parseBlueprint(path);
+  const resources = /* @__PURE__ */ new Map();
+  const bpResources = bp?.resources;
+  if (!bpResources || typeof bpResources !== "object") return resources;
+  for (const [id, resource] of Object.entries(bpResources)) {
+    if (!resource?.type) continue;
+    resources.set(id, {
+      resourceId: id,
+      type: resource.type,
+      physicalName: resource.spec?.name ?? id
+    });
+  }
+  return resources;
+}
+__name(loadBlueprintResources, "loadBlueprintResources");
+function loadWebSocketConfig(blueprintPath) {
+  const path = blueprintPath ?? findBlueprintPath();
+  if (!path) return null;
+  const bp = parseBlueprint(path);
+  if (!bp || typeof bp !== "object") return null;
+  const resources = bp.resources;
+  if (!resources || typeof resources !== "object") return null;
+  for (const resource of Object.values(resources)) {
+    if (!resource || typeof resource !== "object") continue;
+    const res = resource;
+    if (res.type !== "celerity/api" || !res.spec) continue;
+    const spec = res.spec;
+    const { routeKey, authStrategy } = findWsProtocolConfig(spec.protocols);
+    const basePath = findWsBasePath(spec.domain);
+    return {
+      basePath,
+      routeKey,
+      authStrategy
+    };
+  }
+  return null;
+}
+__name(loadWebSocketConfig, "loadWebSocketConfig");
+function findWsProtocolConfig(protocols) {
+  const defaults = {
+    routeKey: "action",
+    authStrategy: "authMessage"
+  };
+  if (!Array.isArray(protocols)) return defaults;
+  for (const proto of protocols) {
+    if (typeof proto !== "object" || !proto) continue;
+    const wsCfg = proto.websocketConfig;
+    if (!wsCfg || typeof wsCfg !== "object") continue;
+    const cfg = wsCfg;
+    return {
+      routeKey: typeof cfg.routeKey === "string" ? cfg.routeKey : defaults.routeKey,
+      authStrategy: cfg.authStrategy === "connect" || cfg.authStrategy === "authMessage" ? cfg.authStrategy : defaults.authStrategy
+    };
+  }
+  return defaults;
+}
+__name(findWsProtocolConfig, "findWsProtocolConfig");
+function findWsBasePath(domain) {
+  if (!domain || typeof domain !== "object") return "/ws";
+  const basePaths = domain.basePaths;
+  if (!Array.isArray(basePaths)) return "/ws";
+  for (const entry of basePaths) {
+    if (typeof entry !== "object" || !entry) continue;
+    const bp = entry;
+    if (bp.protocol !== "websocket") continue;
+    return typeof bp.basePath === "string" ? bp.basePath : "/ws";
+  }
+  return "/ws";
+}
+__name(findWsBasePath, "findWsBasePath");
+function parseBlueprint(filePath) {
+  const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+  const ext = (0, import_node_path.extname)(filePath);
+  if (ext === ".jsonc" || ext === ".json") {
+    return JSON.parse((0, import_strip_json_comments.default)(content, {
+      trailingCommas: true
+    }));
+  }
+  return import_js_yaml.default.load(content);
+}
+__name(parseBlueprint, "parseBlueprint");
+function findBlueprintPath() {
+  const cwd = process.cwd();
+  const candidates = [
+    (0, import_node_path.join)(cwd, "app.blueprint.yaml"),
+    (0, import_node_path.join)(cwd, "app.blueprint.yml"),
+    (0, import_node_path.join)(cwd, "app.blueprint.jsonc"),
+    (0, import_node_path.join)(cwd, "app.blueprint.json")
+  ];
+  for (const candidate of candidates) {
+    if ((0, import_node_fs.existsSync)(candidate)) {
+      return (0, import_node_path.resolve)(candidate);
+    }
+  }
+  return null;
+}
+__name(findBlueprintPath, "findBlueprintPath");
+
+// src/mocks.ts
+function detectMockFnCreator() {
+  const g = globalThis;
+  if (g.jest?.fn) {
+    return g.jest.fn;
+  }
+  if (g.vi?.fn) {
+    return g.vi.fn;
+  }
+  return () => {
+    const fn = /* @__PURE__ */ __name((..._args) => void 0, "fn");
+    return fn;
+  };
+}
+__name(detectMockFnCreator, "detectMockFnCreator");
+function createResourceMock(resourceType, mockFn) {
+  const create = mockFn ?? detectMockFnCreator();
+  switch (resourceType) {
+    case "datastore":
+      return createDatastoreMock(create);
+    case "topic":
+      return createTopicMock(create);
+    case "queue":
+      return createQueueMock(create);
+    case "cache":
+      return createCacheMock(create);
+    case "bucket":
+      return createBucketMock(create);
+    case "config":
+      return createConfigMock(create);
+    default:
+      return null;
+  }
+}
+__name(createResourceMock, "createResourceMock");
+function createDatastoreMock(fn) {
+  return {
+    getItem: fn(),
+    putItem: fn(),
+    deleteItem: fn(),
+    query: fn(),
+    scan: fn(),
+    batchGetItems: fn(),
+    batchWriteItems: fn()
+  };
+}
+__name(createDatastoreMock, "createDatastoreMock");
+function createTopicMock(fn) {
+  return {
+    publish: fn(),
+    publishBatch: fn()
+  };
+}
+__name(createTopicMock, "createTopicMock");
+function createQueueMock(fn) {
+  return {
+    sendMessage: fn(),
+    sendMessageBatch: fn()
+  };
+}
+__name(createQueueMock, "createQueueMock");
+function createCacheMock(fn) {
+  return {
+    get: fn(),
+    set: fn(),
+    delete: fn(),
+    incr: fn(),
+    decr: fn(),
+    incrFloat: fn(),
+    mget: fn(),
+    mset: fn(),
+    mdelete: fn(),
+    exists: fn(),
+    expire: fn(),
+    persist: fn(),
+    ttl: fn(),
+    rename: fn(),
+    getSet: fn(),
+    append: fn(),
+    keyType: fn(),
+    scanKeys: fn(),
+    hashGet: fn(),
+    hashSet: fn(),
+    hashDelete: fn(),
+    hashGetAll: fn(),
+    hashExists: fn(),
+    hashIncr: fn(),
+    hashKeys: fn(),
+    hashLen: fn(),
+    listPush: fn(),
+    listPop: fn(),
+    listRange: fn(),
+    listLen: fn(),
+    listTrim: fn(),
+    listIndex: fn(),
+    setAdd: fn(),
+    setRemove: fn(),
+    setMembers: fn(),
+    setIsMember: fn(),
+    setLen: fn(),
+    setUnion: fn(),
+    setIntersect: fn(),
+    setDiff: fn(),
+    sortedSetAdd: fn(),
+    sortedSetRemove: fn(),
+    sortedSetScore: fn(),
+    sortedSetRank: fn(),
+    sortedSetRange: fn(),
+    sortedSetRangeByScore: fn(),
+    sortedSetIncr: fn(),
+    sortedSetLen: fn(),
+    transaction: fn()
+  };
+}
+__name(createCacheMock, "createCacheMock");
+function createBucketMock(fn) {
+  return {
+    get: fn(),
+    put: fn(),
+    delete: fn(),
+    info: fn(),
+    exists: fn(),
+    list: fn(),
+    copy: fn(),
+    signUrl: fn()
+  };
+}
+__name(createBucketMock, "createBucketMock");
+function createConfigMock(fn) {
+  return {
+    get: fn(),
+    getOrThrow: fn(),
+    getAll: fn(),
+    parse: fn()
+  };
+}
+__name(createConfigMock, "createConfigMock");
+function createMocksForTokens(tokens, mockFn) {
+  const mocks = /* @__PURE__ */ new Map();
+  for (const info of tokens) {
+    const mock = createResourceMock(info.type, mockFn);
+    if (mock) {
+      mocks.set(info.token, mock);
+    }
+  }
+  return mocks;
+}
+__name(createMocksForTokens, "createMocksForTokens");
+
+// src/clients.ts
+async function createRealClients(tokens, blueprintResources) {
+  const handles = /* @__PURE__ */ new Map();
+  const closeables = [];
+  const byType = /* @__PURE__ */ new Map();
+  for (const info of tokens) {
+    const group = byType.get(info.type) ?? [];
+    group.push(info);
+    byType.set(info.type, group);
+  }
+  for (const [type, infos] of byType) {
+    try {
+      switch (type) {
+        case "datastore":
+          await createDatastoreHandles(infos, blueprintResources, handles, closeables);
+          break;
+        case "topic":
+          await createTopicHandles(infos, blueprintResources, handles, closeables);
+          break;
+        case "queue":
+          await createQueueHandles(infos, blueprintResources, handles, closeables);
+          break;
+        case "cache":
+          await createCacheHandles(infos, handles, closeables);
+          break;
+        case "bucket":
+          await createBucketHandles(infos, blueprintResources, handles, closeables);
+          break;
+        case "sqlDatabase":
+          await createSqlHandles(infos, blueprintResources, handles, closeables);
+          break;
+        case "config":
+          await createConfigHandles(infos, handles);
+          break;
+      }
+    } catch (err) {
+      const pkg = type === "sqlDatabase" ? "sql-database" : type;
+      throw new Error(`Failed to create ${type} client for integration test. Is @celerity-sdk/${pkg} installed? Error: ${err}`);
+    }
+  }
+  return {
+    handles,
+    closeables
+  };
+}
+__name(createRealClients, "createRealClients");
+function physicalName(info, bp) {
+  return bp.get(info.name)?.physicalName ?? info.name;
+}
+__name(physicalName, "physicalName");
+async function createConfigHandles(infos, handles) {
+  const { ConfigNamespaceImpl, LocalConfigBackend } = await import("@celerity-sdk/config");
+  const backend = new LocalConfigBackend();
+  for (const info of infos) {
+    const envKey = info.name.toUpperCase();
+    const storeId = process.env[`CELERITY_CONFIG_${envKey}_STORE_ID`] ?? info.name;
+    const ns = new ConfigNamespaceImpl(backend, storeId);
+    handles.set(info.token, ns);
+  }
+}
+__name(createConfigHandles, "createConfigHandles");
+async function createDatastoreHandles(infos, bp, handles, closeables) {
+  const { createDatastoreClient } = await import("@celerity-sdk/datastore");
+  const client = await createDatastoreClient({
+    provider: "local"
+  });
+  closeables.push(client);
+  for (const info of infos) {
+    handles.set(info.token, client.datastore(physicalName(info, bp)));
+  }
+}
+__name(createDatastoreHandles, "createDatastoreHandles");
+async function createTopicHandles(infos, bp, handles, closeables) {
+  const { createTopicClient } = await import("@celerity-sdk/topic");
+  const client = await createTopicClient({
+    provider: "local"
+  });
+  closeables.push(client);
+  for (const info of infos) {
+    handles.set(info.token, client.topic(physicalName(info, bp)));
+  }
+}
+__name(createTopicHandles, "createTopicHandles");
+async function createQueueHandles(infos, bp, handles, closeables) {
+  const { createQueueClient } = await import("@celerity-sdk/queue");
+  const client = await createQueueClient({
+    provider: "local"
+  });
+  closeables.push(client);
+  for (const info of infos) {
+    handles.set(info.token, client.queue(physicalName(info, bp)));
+  }
+}
+__name(createQueueHandles, "createQueueHandles");
+async function createCacheHandles(infos, handles, closeables) {
+  const { createCacheClient } = await import("@celerity-sdk/cache");
+  const endpoint = process.env.CELERITY_REDIS_ENDPOINT ?? "redis://localhost:6379";
+  const url = new URL(endpoint);
+  const client = await createCacheClient({
+    config: {
+      host: url.hostname,
+      port: Number.parseInt(url.port || "6379", 10),
+      tls: false,
+      clusterMode: false,
+      authMode: "password",
+      connectionConfig: {
+        connectTimeoutMs: 5e3,
+        commandTimeoutMs: 5e3,
+        keepAliveMs: 0,
+        maxRetries: 3,
+        retryDelayMs: 100,
+        lazyConnect: false
+      }
+    }
+  });
+  closeables.push(client);
+  for (const info of infos) {
+    handles.set(info.token, client.cache(info.name));
+  }
+}
+__name(createCacheHandles, "createCacheHandles");
+async function createBucketHandles(infos, bp, handles, closeables) {
+  const { createObjectStorage } = await import("@celerity-sdk/bucket");
+  const client = await createObjectStorage({
+    provider: "local"
+  });
+  closeables.push(client);
+  for (const info of infos) {
+    handles.set(info.token, client.bucket(physicalName(info, bp)));
+  }
+}
+__name(createBucketHandles, "createBucketHandles");
+async function createSqlHandles(infos, bp, handles, closeables) {
+  const connStr = process.env.CELERITY_LOCAL_SQL_DATABASE_ENDPOINT;
+  if (!connStr) {
+    throw new Error("CELERITY_LOCAL_SQL_DATABASE_ENDPOINT must be set for SQL database integration tests");
+  }
+  const { createKnexInstance } = await import("@celerity-sdk/sql-database");
+  const knexByResource = /* @__PURE__ */ new Map();
+  for (const info of infos) {
+    const resourceName = sqlResourceName(info.name);
+    const lookupInfo = {
+      ...info,
+      name: resourceName
+    };
+    const dbName = physicalName(lookupInfo, bp);
+    if (!knexByResource.has(dbName)) {
+      const url = new URL(connStr);
+      const engine = sqlEngineFromProtocol(url.protocol);
+      const defaultPort = engine === "mysql" ? "3306" : "5432";
+      const knexPromise = createKnexInstance({
+        credentials: {
+          getConnectionInfo: /* @__PURE__ */ __name(async () => ({
+            engine,
+            host: url.hostname,
+            port: Number.parseInt(url.port || defaultPort, 10),
+            user: url.username,
+            database: dbName,
+            ssl: false,
+            authMode: "password"
+          }), "getConnectionInfo"),
+          getPasswordAuth: /* @__PURE__ */ __name(async () => ({
+            password: url.password,
+            url: connStr
+          }), "getPasswordAuth"),
+          getIamAuth: /* @__PURE__ */ __name(async () => {
+            throw new Error("IAM auth not supported in local mode");
+          }, "getIamAuth")
+        },
+        deployTarget: "functions"
+      });
+      knexByResource.set(dbName, knexPromise);
+      closeables.push({
+        close: /* @__PURE__ */ __name(async () => (await knexPromise).destroy(), "close")
+      });
+    }
+    const knex = await knexByResource.get(dbName);
+    handles.set(info.token, knex);
+  }
+}
+__name(createSqlHandles, "createSqlHandles");
+function sqlEngineFromProtocol(protocol) {
+  if (protocol === "mysql:" || protocol === "mysql2:") return "mysql";
+  return "postgres";
+}
+__name(sqlEngineFromProtocol, "sqlEngineFromProtocol");
+function sqlResourceName(tokenName) {
+  const colonIdx = tokenName.indexOf(":");
+  if (colonIdx === -1) return tokenName;
+  return tokenName.slice(colonIdx + 1);
+}
+__name(sqlResourceName, "sqlResourceName");
+
+// src/test-app.ts
+var TestApp = class {
+  static {
+    __name(this, "TestApp");
+  }
+  mocks;
+  closeables;
+  inner;
+  constructor(inner, mocks, closeables) {
+    this.inner = inner;
+    this.mocks = mocks;
+    this.closeables = closeables;
+  }
+  // -- Delegate to TestingApplication --
+  injectHttp(request) {
+    return this.inner.injectHttp(request);
+  }
+  injectWebSocket(route, message) {
+    return this.inner.injectWebSocket(route, message);
+  }
+  injectConsumer(handlerTag, event) {
+    return this.inner.injectConsumer(handlerTag, event);
+  }
+  injectSchedule(handlerTag, event) {
+    return this.inner.injectSchedule(handlerTag, event);
+  }
+  injectCustom(name, payload) {
+    return this.inner.injectCustom(name, payload);
+  }
+  getContainer() {
+    return this.inner.getContainer();
+  }
+  getRegistry() {
+    return this.inner.getRegistry();
+  }
+  // -- Mock access (unit mode) --
+  /** Retrieve the auto-generated mock for a resource token. */
+  getMock(token) {
+    const mock = this.mocks.get(token);
+    if (!mock) {
+      throw new Error(`No mock found for token: ${String(token)}`);
+    }
+    return mock;
+  }
+  /** Get the mock Datastore for a named resource (e.g., "usersDatastore"). */
+  getDatastoreMock(name) {
+    return this.getMock(/* @__PURE__ */ Symbol.for(`celerity:datastore:${name}`));
+  }
+  /** Get the mock Topic for a named resource. */
+  getTopicMock(name) {
+    return this.getMock(/* @__PURE__ */ Symbol.for(`celerity:topic:${name}`));
+  }
+  /** Get the mock Queue for a named resource. */
+  getQueueMock(name) {
+    return this.getMock(/* @__PURE__ */ Symbol.for(`celerity:queue:${name}`));
+  }
+  /** Get the mock Cache for a named resource. */
+  getCacheMock(name) {
+    return this.getMock(/* @__PURE__ */ Symbol.for(`celerity:cache:${name}`));
+  }
+  /** Get the mock Bucket for a named resource. */
+  getBucketMock(name) {
+    return this.getMock(/* @__PURE__ */ Symbol.for(`celerity:bucket:${name}`));
+  }
+  /** Get the mock Config namespace for a named resource. */
+  getConfigMock(name) {
+    return this.getMock(/* @__PURE__ */ Symbol.for(`celerity:config:${name}`));
+  }
+  // -- Lifecycle --
+  /** Close all real resource clients (integration mode). No-op in unit mode. */
+  async close() {
+    for (const client of this.closeables) {
+      try {
+        await client.close?.();
+      } catch {
+      }
+    }
+  }
+};
+async function createTestApp(options) {
+  const { providers = [], controllers = [], guards = [], overrides = {} } = options;
+  const { inner, mocks, closeables } = await setupResources(options);
+  const container = inner.getContainer();
+  for (const provider of providers) {
+    if (typeof provider === "function") {
+      container.registerClass(provider);
+    } else {
+      container.register(provider.provide, provider);
+    }
+  }
+  for (const ctrl of controllers) {
+    if (!container.has(ctrl)) container.registerClass(ctrl);
+  }
+  for (const guard of guards) {
+    if (!container.has(guard)) container.registerClass(guard);
+  }
+  applyOverrides(container, overrides);
+  return new TestApp(inner, mocks, closeables);
+}
+__name(createTestApp, "createTestApp");
+async function setupResources(options) {
+  const { module: rootModule, integration = false, blueprintPath } = options;
+  const resourceInfos = discoverResourceTokens(rootModule);
+  let mocks = /* @__PURE__ */ new Map();
+  let closeables = [];
+  let resourceHandles = /* @__PURE__ */ new Map();
+  if (integration) {
+    const blueprintResources = loadBlueprintResources(blueprintPath);
+    const result = await createRealClients(resourceInfos, blueprintResources);
+    resourceHandles = result.handles;
+    closeables = result.closeables;
+  } else {
+    mocks = createMocksForTokens(resourceInfos);
+    for (const [token, mock] of mocks) {
+      resourceHandles.set(token, mock);
+    }
+  }
+  const inner = await import_core2.CelerityFactory.createTestingApp(rootModule, {
+    systemLayers: []
+  });
+  const container = inner.getContainer();
+  for (const [token, handle] of resourceHandles) {
+    container.registerValue(token, handle);
+  }
+  return {
+    inner,
+    mocks,
+    closeables
+  };
+}
+__name(setupResources, "setupResources");
+function applyOverrides(container, overrides) {
+  for (const [token, value] of Object.entries(overrides)) {
+    container.registerValue(token, value);
+  }
+  for (const sym of Object.getOwnPropertySymbols(overrides)) {
+    container.registerValue(sym, overrides[sym]);
+  }
+}
+__name(applyOverrides, "applyOverrides");
+
+// src/jwt.ts
+async function generateTestToken(options) {
+  const baseURL = process.env.CELERITY_DEV_AUTH_BASE_URL ?? "http://localhost:9099";
+  const body = {
+    sub: options?.sub ?? "test-user"
+  };
+  if (options?.claims) {
+    body.claims = options.claims;
+  }
+  if (options?.expiresIn) {
+    body.expiresIn = options.expiresIn;
+  }
+  const response = await fetch(`${baseURL}/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Dev auth server returned ${response.status}: ${text}`);
+  }
+  const data = await response.json();
+  return data.access_token;
+}
+__name(generateTestToken, "generateTestToken");
+
+// src/http.ts
+var TestRequest = class {
+  static {
+    __name(this, "TestRequest");
+  }
+  baseUrl;
+  method;
+  path;
+  _headers = {};
+  _body;
+  _expectations = [];
+  constructor(baseUrl, method, path) {
+    this.baseUrl = baseUrl;
+    this.method = method;
+    this.path = path;
+  }
+  /** Set an authorization bearer token. */
+  auth(token) {
+    this._headers["Authorization"] = `Bearer ${token}`;
+    return this;
+  }
+  /** Set a request header. */
+  set(key, value) {
+    this._headers[key] = value;
+    return this;
+  }
+  /** Set the request JSON body. */
+  send(body) {
+    this._body = body;
+    return this;
+  }
+  expect(first, second) {
+    if (typeof first === "number") {
+      this._expectations.push({
+        type: "status",
+        value: first
+      });
+    } else if (typeof first === "string" && second !== void 0) {
+      this._expectations.push({
+        type: "header",
+        key: first.toLowerCase(),
+        value: second
+      });
+    } else if (typeof first === "function") {
+      this._expectations.push({
+        type: "body",
+        value: first
+      });
+    } else {
+      this._expectations.push({
+        type: "body",
+        value: first
+      });
+    }
+    return this;
+  }
+  /** Execute the request and run all expectations. Returns the response. */
+  async end() {
+    const headers = {
+      ...this._headers
+    };
+    if (this._body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    const response = await fetch(`${this.baseUrl}${this.path}`, {
+      method: this.method,
+      headers,
+      body: this._body !== void 0 ? JSON.stringify(this._body) : void 0
+    });
+    const text = await response.text();
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = text;
+    }
+    const result = {
+      status: response.status,
+      headers: response.headers,
+      body,
+      text
+    };
+    for (const exp of this._expectations) {
+      this.assertExpectation(exp, result, text);
+    }
+    return result;
+  }
+  assertExpectation(exp, result, text) {
+    if (exp.type === "status") {
+      if (result.status !== exp.value) {
+        throw new Error(`Expected status ${exp.value} but got ${result.status}.
+Body: ${text}`);
+      }
+      return;
+    }
+    if (exp.type === "body") {
+      if (typeof exp.value === "function") {
+        exp.value(result.body);
+      } else {
+        const expected = JSON.stringify(exp.value);
+        const actual = JSON.stringify(result.body);
+        if (expected !== actual) {
+          throw new Error(`Expected body ${expected} but got ${actual}`);
+        }
+      }
+      return;
+    }
+    if (exp.type === "header") {
+      this.assertHeader(exp.key, exp.value, result.headers);
+    }
+  }
+  assertHeader(key, expected, headers) {
+    const actual = headers.get(key);
+    if (expected instanceof RegExp) {
+      if (!actual || !expected.test(actual)) {
+        throw new Error(`Expected header "${key}" to match ${expected} but got "${actual}"`);
+      }
+      return;
+    }
+    if (actual !== expected) {
+      throw new Error(`Expected header "${key}" to be "${expected}" but got "${actual}"`);
+    }
+  }
+  /** Implements PromiseLike so the request chain can be awaited directly. */
+  then(resolve2, reject) {
+    return this.end().then(resolve2, reject);
+  }
+};
+var TestHttpClient = class {
+  static {
+    __name(this, "TestHttpClient");
+  }
+  baseUrl;
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  get(path) {
+    return new TestRequest(this.baseUrl, "GET", path);
+  }
+  post(path) {
+    return new TestRequest(this.baseUrl, "POST", path);
+  }
+  put(path) {
+    return new TestRequest(this.baseUrl, "PUT", path);
+  }
+  patch(path) {
+    return new TestRequest(this.baseUrl, "PATCH", path);
+  }
+  delete(path) {
+    return new TestRequest(this.baseUrl, "DELETE", path);
+  }
+};
+function createTestClient(options) {
+  const baseUrl = options?.baseUrl ?? process.env.CELERITY_TEST_BASE_URL ?? "http://localhost:8081";
+  return new TestHttpClient(baseUrl);
+}
+__name(createTestClient, "createTestClient");
+
+// src/wait.ts
+async function waitFor(predicate, options) {
+  const timeout = options?.timeout ?? 5e3;
+  const interval = options?.interval ?? 100;
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    const result = await predicate();
+    if (result) return;
+    await new Promise((resolve2) => setTimeout(resolve2, interval));
+  }
+  throw new Error(`waitFor timed out after ${timeout}ms`);
+}
+__name(waitFor, "waitFor");
+
+// src/ws.ts
+async function createTestWsClient(options) {
+  const wsModule = await import("@celerity-sdk/ws-client");
+  const wsConfig = loadWebSocketConfig(options?.blueprintPath);
+  const basePath = wsConfig?.basePath ?? "/ws";
+  const routeKey = wsConfig?.routeKey ?? "action";
+  const authStrategy = wsConfig?.authStrategy ?? "authMessage";
+  const baseUrl = process.env.CELERITY_TEST_BASE_URL ?? "http://localhost:8081";
+  const wsUrl = options?.url ?? baseUrl.replace(/^http/, "ws") + basePath;
+  const authConfig = resolveAuthConfig(options?.token, authStrategy);
+  const innerClient = await wsModule.createWsClient({
+    url: wsUrl,
+    routeKey,
+    auth: authConfig,
+    ...options?.clientConfig
+  });
+  return new TestWsClient(innerClient);
+}
+__name(createTestWsClient, "createTestWsClient");
+var TestWsClient = class {
+  static {
+    __name(this, "TestWsClient");
+  }
+  inner;
+  messageBuffer = [];
+  waiters = [];
+  cleanups = [];
+  connectionError = null;
+  constructor(inner) {
+    this.inner = inner;
+  }
+  /**
+  * Connect and complete the full handshake (including auth if configured).
+  *
+  * After connect resolves, `nextMessage()` will receive application messages.
+  * If auth fails or connection is rejected, the promise rejects with the error.
+  */
+  async connect() {
+    const errorUnsub = this.inner.on("error", (err) => {
+      this.connectionError = err;
+      this.rejectAllWaiters(err);
+    });
+    this.cleanups.push(errorUnsub);
+    const disconnectUnsub = this.inner.on("disconnected", () => {
+      this.rejectAllWaiters(new Error("WebSocket disconnected while waiting for message"));
+    });
+    this.cleanups.push(disconnectUnsub);
+    const messageUnsub = this.inner.on("*", (data, meta) => {
+      const route = meta?.route ?? "";
+      const msg = {
+        route,
+        data
+      };
+      if (this.waiters.length > 0) {
+        const waiter = this.waiters.shift();
+        clearTimeout(waiter.timer);
+        waiter.resolve(msg);
+      } else {
+        this.messageBuffer.push(msg);
+      }
+    });
+    this.cleanups.push(messageUnsub);
+    await this.inner.connect();
+  }
+  /** Send a routed application message. Returns the message ID. */
+  send(route, data) {
+    return this.inner.send(route, data);
+  }
+  /**
+  * Wait for the next application message from the server.
+  *
+  * If a message is already buffered, resolves immediately.
+  * Otherwise blocks until a message arrives, the connection closes, or timeout expires.
+  *
+  * @param timeout - Maximum wait time in ms. Default: 5000.
+  */
+  nextMessage(timeout = 5e3) {
+    if (this.connectionError) {
+      return Promise.reject(this.connectionError);
+    }
+    if (this.messageBuffer.length > 0) {
+      return Promise.resolve(this.messageBuffer.shift());
+    }
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        const idx = this.waiters.findIndex((w) => w.resolve === resolve2);
+        if (idx !== -1) this.waiters.splice(idx, 1);
+        reject(new Error(`nextMessage timed out after ${timeout}ms`));
+      }, timeout);
+      this.waiters.push({
+        resolve: resolve2,
+        reject,
+        timer
+      });
+    });
+  }
+  /** Disconnect and clean up all listeners and pending waiters. */
+  async disconnect() {
+    this.cleanup();
+    await this.inner.disconnect();
+  }
+  /** Force destroy without waiting for close handshake. */
+  destroy() {
+    this.cleanup();
+    this.inner.destroy();
+  }
+  /** Current connection state. */
+  get state() {
+    return this.inner.state;
+  }
+  /** Access the underlying CelerityWsClient for advanced usage. */
+  get raw() {
+    return this.inner;
+  }
+  cleanup() {
+    for (const unsub of this.cleanups) unsub();
+    this.cleanups = [];
+    this.rejectAllWaiters(new Error("WebSocket client closed"));
+    this.messageBuffer = [];
+  }
+  rejectAllWaiters(err) {
+    for (const waiter of this.waiters) {
+      clearTimeout(waiter.timer);
+      waiter.reject(err);
+    }
+    this.waiters = [];
+  }
+};
+function resolveAuthConfig(token, authStrategy) {
+  if (token === null) return void 0;
+  if (typeof token === "string") return {
+    strategy: authStrategy,
+    token
+  };
+  const tokenOpts = token ?? {
+    sub: "test-user",
+    claims: {
+      roles: [
+        "admin"
+      ]
+    }
+  };
+  return {
+    strategy: authStrategy,
+    token: /* @__PURE__ */ __name(() => generateTestToken(tokenOpts), "token")
+  };
+}
+__name(resolveAuthConfig, "resolveAuthConfig");
+
+// src/index.ts
+var import_core3 = require("@celerity-sdk/core");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestApp,
+  TestHttpClient,
+  TestRequest,
+  TestWsClient,
+  createMocksForTokens,
+  createResourceMock,
+  createTestApp,
+  createTestClient,
+  createTestWsClient,
+  discoverResourceTokens,
+  generateTestToken,
+  loadBlueprintResources,
+  loadWebSocketConfig,
+  mockConsumerEvent,
+  mockRequest,
+  mockScheduleEvent,
+  mockWebSocketMessage,
+  waitFor
+});
+//# sourceMappingURL=index.cjs.map