@tradejs/infra 3.1.8-beta.207 → 3.1.8-beta.210

package/dist/runtimeStrategyReleases.d.ts

@@ -1,26 +0,0 @@
-import { StrategyConfig, RuntimeStrategyRelease, RuntimeStrategyControlState, RuntimeStrategyControlEvent } from '@tradejs/types';
-
-declare const assertRuntimeStrategyReleaseConfig: (config: StrategyConfig) => void;
-declare const verifyRuntimeStrategyRelease: (value: unknown) => RuntimeStrategyRelease;
-declare const getRuntimeStrategyRelease: (userName: string, strategyName: string, releaseVersion: number) => Promise<RuntimeStrategyRelease | null>;
-declare const listRuntimeStrategyReleases: (userName: string, strategyName: string) => Promise<RuntimeStrategyRelease[]>;
-declare const publishRuntimeStrategyRelease: ({ userName, strategyName, config, strategyPackage, strategyPackageVersion, runtimePackageVersion, createdBy, }: {
-    userName: string;
-    strategyName: string;
-    config: StrategyConfig;
-    strategyPackage: string;
-    strategyPackageVersion: string;
-    runtimePackageVersion: string;
-    createdBy: string;
-}) => Promise<RuntimeStrategyRelease>;
-declare const recordRuntimeStrategyControlEvent: ({ userName, deploymentId, strategyName, releaseVersion, previousState, nextState, createdBy, }: {
-    userName: string;
-    deploymentId: string;
-    strategyName: string;
-    releaseVersion: number;
-    previousState: RuntimeStrategyControlState;
-    nextState: RuntimeStrategyControlState;
-    createdBy: string;
-}) => Promise<RuntimeStrategyControlEvent>;
-
-export { assertRuntimeStrategyReleaseConfig, getRuntimeStrategyRelease, listRuntimeStrategyReleases, publishRuntimeStrategyRelease, recordRuntimeStrategyControlEvent, verifyRuntimeStrategyRelease };

package/dist/runtimeStrategyReleases.mjs

@@ -1,196 +0,0 @@
-import {
-  getData,
-  getKeys,
-  incrementKey,
-  redisKeys,
-  setData,
-  setDataIfAbsent
-} from "./chunk-JLVCBKE3.mjs";
-
-// src/runtimeStrategyReleases.ts
-import { createHash, randomUUID } from "crypto";
-import {
-  RUNTIME_STRATEGY_RELEASE_SCHEMA
-} from "@tradejs/types";
-var SHA256_RE = /^[a-f0-9]{64}$/;
-var FORBIDDEN_RELEASE_CONFIG_KEYS = /* @__PURE__ */ new Set([
-  "ACCOUNT_ID",
-  "AI_REPLAY_ANALYSES",
-  "DEPLOYMENT_ID",
-  "ENABLE",
-  "ENV",
-  "MAKE_ORDERS",
-  "RECORD_RUNTIME_TRADES",
-  "configId"
-]);
-var SECRET_CONFIG_KEY_RE = /(?:^|_)(?:API_KEY|API_SECRET|TOKEN|PASSWORD|PRIVATE_KEY)$/i;
-var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-var canonicalJson = (value) => {
-  const normalize = (current) => {
-    if (Array.isArray(current)) return current.map(normalize);
-    const record = asRecord(current);
-    if (!record) return current;
-    return Object.fromEntries(
-      Object.entries(record).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalize(entry)])
-    );
-  };
-  return JSON.stringify(normalize(value));
-};
-var releaseContentSha256 = (release) => createHash("sha256").update(canonicalJson(release)).digest("hex");
-var assertStrategyName = (strategyName) => {
-  if (!/^[a-zA-Z0-9_-]+$/.test(strategyName)) {
-    throw new Error(`Invalid strategy name: ${strategyName}`);
-  }
-};
-var assertPackageIdentity = (value, label) => {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`${label} is required for a runtime strategy release`);
-  }
-};
-var assertRuntimeStrategyReleaseConfig = (config) => {
-  const record = asRecord(config);
-  if (!record) throw new Error("Strategy release config must be an object");
-  for (const key of FORBIDDEN_RELEASE_CONFIG_KEYS) {
-    if (record[key] !== void 0) {
-      throw new Error(`${key} is a deployment binding, not release config`);
-    }
-  }
-  const inspect = (value, parentPath = "") => {
-    if (Array.isArray(value)) {
-      value.forEach(
-        (entry, index) => inspect(entry, `${parentPath}[${index}]`)
-      );
-      return;
-    }
-    const current = asRecord(value);
-    if (!current) return;
-    for (const [key, entry] of Object.entries(current)) {
-      const keyPath = parentPath ? `${parentPath}.${key}` : key;
-      if (SECRET_CONFIG_KEY_RE.test(key)) {
-        throw new Error(`${keyPath} is secret material, not release config`);
-      }
-      inspect(entry, keyPath);
-    }
-  };
-  inspect(record);
-  if (typeof record.INTERVAL !== "string" || !record.INTERVAL.trim()) {
-    throw new Error("Published strategy config must define INTERVAL");
-  }
-  if (record.UNIVERSE !== "crypto" && record.UNIVERSE !== "tradfi") {
-    throw new Error("Published strategy config must define a valid UNIVERSE");
-  }
-};
-var isRelease = (value) => {
-  const release = asRecord(value);
-  return Boolean(
-    release?.schema === RUNTIME_STRATEGY_RELEASE_SCHEMA && typeof release.strategyName === "string" && Number.isSafeInteger(release.releaseVersion) && Number(release.releaseVersion) > 0 && asRecord(release.config) && typeof release.strategyPackage === "string" && Boolean(release.strategyPackage.trim()) && typeof release.strategyPackageVersion === "string" && Boolean(release.strategyPackageVersion.trim()) && typeof release.runtimePackageVersion === "string" && Boolean(release.runtimePackageVersion.trim()) && typeof release.createdAt === "number" && typeof release.createdBy === "string" && typeof release.contentSha256 === "string" && SHA256_RE.test(release.contentSha256)
-  );
-};
-var verifyRuntimeStrategyRelease = (value) => {
-  if (!isRelease(value)) throw new Error("Invalid runtime strategy release");
-  const { contentSha256, ...content } = value;
-  if (releaseContentSha256(content) !== contentSha256) {
-    throw new Error(
-      `${value.strategyName} v${value.releaseVersion} content checksum mismatch`
-    );
-  }
-  assertRuntimeStrategyReleaseConfig(value.config);
-  return value;
-};
-var getRuntimeStrategyRelease = async (userName, strategyName, releaseVersion) => {
-  const value = await getData(
-    redisKeys.runtimeStrategyRelease(userName, strategyName, releaseVersion),
-    null
-  );
-  return value == null ? null : verifyRuntimeStrategyRelease(value);
-};
-var listRuntimeStrategyReleases = async (userName, strategyName) => {
-  const keys = await getKeys(
-    redisKeys.runtimeStrategyReleases(userName, strategyName)
-  );
-  const releases = await Promise.all(
-    keys.map(async (key) => {
-      const value = await getData(key, null);
-      return value == null ? null : verifyRuntimeStrategyRelease(value);
-    })
-  );
-  return releases.filter((release) => release != null).sort((left, right) => right.releaseVersion - left.releaseVersion);
-};
-var publishRuntimeStrategyRelease = async ({
-  userName,
-  strategyName,
-  config,
-  strategyPackage,
-  strategyPackageVersion,
-  runtimePackageVersion,
-  createdBy
-}) => {
-  assertStrategyName(strategyName);
-  assertRuntimeStrategyReleaseConfig(config);
-  assertPackageIdentity(strategyPackage, "strategyPackage");
-  assertPackageIdentity(strategyPackageVersion, "strategyPackageVersion");
-  assertPackageIdentity(runtimePackageVersion, "runtimePackageVersion");
-  const releaseVersion = await incrementKey(
-    redisKeys.runtimeStrategyReleaseSequence(userName, strategyName)
-  );
-  const content = {
-    schema: RUNTIME_STRATEGY_RELEASE_SCHEMA,
-    strategyName,
-    releaseVersion,
-    config,
-    strategyPackage,
-    strategyPackageVersion,
-    runtimePackageVersion,
-    createdAt: Date.now(),
-    createdBy
-  };
-  const release = {
-    ...content,
-    contentSha256: releaseContentSha256(content)
-  };
-  const stored = await setDataIfAbsent(
-    redisKeys.runtimeStrategyRelease(userName, strategyName, releaseVersion),
-    release
-  );
-  if (!stored) {
-    throw new Error(`Refused to overwrite ${strategyName} v${releaseVersion}`);
-  }
-  return release;
-};
-var recordRuntimeStrategyControlEvent = async ({
-  userName,
-  deploymentId,
-  strategyName,
-  releaseVersion,
-  previousState,
-  nextState,
-  createdBy
-}) => {
-  const action = nextState === "entries_paused" ? "pause_entries" : "resume";
-  const createdAt = Date.now();
-  const event = {
-    eventId: `${createdAt}-${randomUUID()}`,
-    deploymentId,
-    strategyName,
-    releaseVersion,
-    action,
-    previousState,
-    nextState,
-    createdAt,
-    createdBy
-  };
-  await setData(
-    redisKeys.runtimeStrategyControlEvent(userName, event.eventId),
-    event,
-    { expire: 0 }
-  );
-  return event;
-};
-export {
-  assertRuntimeStrategyReleaseConfig,
-  getRuntimeStrategyRelease,
-  listRuntimeStrategyReleases,
-  publishRuntimeStrategyRelease,
-  recordRuntimeStrategyControlEvent,
-  verifyRuntimeStrategyRelease
-};