progressive-zod 1.1.2 → 1.2.0

package/dist/cli/index.js

@@ -88,7 +88,8 @@ var init_redis = __esm({
         if (!this.redis) {
           let Redis;
           try {
-            Redis = (await import("ioredis")).default;
+            const moduleName = "ioredis";
+            Redis = (await import(moduleName)).default;
           } catch {
             throw new Error(
               "ioredis is required for Redis storage. Install it with: npm install ioredis"
@@ -286,9 +287,13 @@ var MemoryStorage = class {
   }
 };
 
-// src/storage/index.ts
+// src/storage/resolve.ts
 var currentConfig = {};
 var currentStorage = null;
+var storageFactory = async (config) => new MemoryStorage(config);
+function _setStorageFactory(factory) {
+  storageFactory = factory;
+}
 function getConfig() {
   return {
     storage: currentConfig.storage ?? process.env.PROGRESSIVE_ZOD_STORAGE ?? "memory",
@@ -302,28 +307,32 @@ function getConfig() {
 async function getStorage() {
   if (currentStorage) return currentStorage;
   const config = getConfig();
+  currentStorage = await storageFactory(config, currentConfig);
+  return currentStorage;
+}
+async function disconnectStorage() {
+  if (currentStorage) {
+    await currentStorage.disconnect();
+    currentStorage = null;
+  }
+}
+
+// src/storage/index.ts
+_setStorageFactory(async (config, userConfig) => {
   if (config.storage === "amplitude") {
-    if (!currentConfig.amplitudeClient) {
+    if (!userConfig.amplitudeClient) {
       throw new Error(
         "progressive-zod: storage is set to 'amplitude' but no amplitudeClient was provided. Pass an Amplitude client instance via configure({ amplitudeClient })."
       );
     }
     const { AmplitudeStorage: AmplitudeStorage2 } = await Promise.resolve().then(() => (init_amplitude(), amplitude_exports));
-    currentStorage = new AmplitudeStorage2(currentConfig.amplitudeClient, config);
+    return new AmplitudeStorage2(userConfig.amplitudeClient, config);
   } else if (config.storage === "redis") {
     const { RedisStorage: RedisStorage2 } = await Promise.resolve().then(() => (init_redis(), redis_exports));
-    currentStorage = new RedisStorage2(config);
-  } else {
-    currentStorage = new MemoryStorage(config);
+    return new RedisStorage2(config);
   }
-  return currentStorage;
-}
-async function disconnectStorage() {
-  if (currentStorage) {
-    await currentStorage.disconnect();
-    currentStorage = null;
-  }
-}
+  return new MemoryStorage(config);
+});
 
 // src/cli/commands/list.ts
 async function listCommand() {

package/dist/client.cjs

@@ -0,0 +1,645 @@
+"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 __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/storage/amplitude.ts
+var amplitude_exports = {};
+__export(amplitude_exports, {
+  AmplitudeStorage: () => AmplitudeStorage
+});
+var AmplitudeStorage;
+var init_amplitude = __esm({
+  "src/storage/amplitude.ts"() {
+    "use strict";
+    AmplitudeStorage = class {
+      client;
+      deviceId;
+      constructor(client, config) {
+        this.client = client;
+        this.deviceId = `pzod:${config.keyPrefix ?? "default"}`;
+      }
+      addName(_name) {
+      }
+      addSample(_name, _sample) {
+      }
+      addViolation(_name, _violation) {
+      }
+      incrConform(name) {
+        this.client.track(
+          "pzod:type_checked",
+          { type_name: name, result: "conform" },
+          { device_id: this.deviceId }
+        );
+      }
+      incrViolate(name) {
+        this.client.track(
+          "pzod:type_checked",
+          { type_name: name, result: "violate" },
+          { device_id: this.deviceId }
+        );
+      }
+      // --- Read methods: no-ops (use Amplitude dashboard) ---
+      async getNames() {
+        return [];
+      }
+      async getSamples(_name) {
+        return [];
+      }
+      async getViolations(_name, _limit) {
+        return [];
+      }
+      async getStats(_name) {
+        return { conform: 0, violate: 0 };
+      }
+      disconnect() {
+      }
+    };
+  }
+});
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  configure: () => configure,
+  configureBatch: () => configureBatch,
+  forceFlush: () => forceFlush,
+  inferSchema: () => inferSchema,
+  progressive: () => progressive,
+  schemaToCode: () => schemaToCode,
+  shutdown: () => shutdown
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/storage/memory.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var MemoryStorage = class {
+  names = /* @__PURE__ */ new Set();
+  data = /* @__PURE__ */ new Map();
+  maxSamples;
+  maxViolations;
+  dataDir;
+  flushTimer;
+  constructor(config = {}) {
+    this.maxSamples = config.maxSamples ?? 1e3;
+    this.maxViolations = config.maxViolations ?? 1e3;
+    this.dataDir = config.dataDir;
+    if (this.dataDir) {
+      this.loadFromDisk();
+    }
+  }
+  getOrCreate(name) {
+    let entry = this.data.get(name);
+    if (!entry) {
+      entry = { samples: [], violations: [], conform: 0, violate: 0 };
+      this.data.set(name, entry);
+    }
+    return entry;
+  }
+  addName(name) {
+    this.names.add(name);
+    this.schedulePersist();
+  }
+  addSample(name, sample) {
+    const entry = this.getOrCreate(name);
+    entry.samples.unshift(sample);
+    if (entry.samples.length > this.maxSamples) {
+      entry.samples.length = this.maxSamples;
+    }
+    this.schedulePersist();
+  }
+  addViolation(name, violation) {
+    const entry = this.getOrCreate(name);
+    entry.violations.unshift(violation);
+    if (entry.violations.length > this.maxViolations) {
+      entry.violations.length = this.maxViolations;
+    }
+    this.schedulePersist();
+  }
+  incrConform(name) {
+    this.getOrCreate(name).conform++;
+    this.schedulePersist();
+  }
+  incrViolate(name) {
+    this.getOrCreate(name).violate++;
+    this.schedulePersist();
+  }
+  getNames() {
+    return [...this.names].sort();
+  }
+  getSamples(name) {
+    return this.getOrCreate(name).samples;
+  }
+  getViolations(name, limit) {
+    return this.getOrCreate(name).violations.slice(0, limit);
+  }
+  async getStats(name) {
+    const entry = this.getOrCreate(name);
+    return { conform: entry.conform, violate: entry.violate };
+  }
+  disconnect() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = void 0;
+    }
+    if (this.dataDir) {
+      this.persistToDisk();
+    }
+  }
+  schedulePersist() {
+    if (!this.dataDir || this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = void 0;
+      this.persistToDisk();
+    }, 500);
+  }
+  persistToDisk() {
+    if (!this.dataDir) return;
+    try {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+      const snapshot = {
+        names: [...this.names],
+        types: Object.fromEntries(this.data)
+      };
+      fs.writeFileSync(
+        path.join(this.dataDir, "data.json"),
+        JSON.stringify(snapshot, null, 2)
+      );
+    } catch {
+    }
+  }
+  loadFromDisk() {
+    if (!this.dataDir) return;
+    try {
+      const raw = fs.readFileSync(
+        path.join(this.dataDir, "data.json"),
+        "utf-8"
+      );
+      const snapshot = JSON.parse(raw);
+      if (Array.isArray(snapshot.names)) {
+        for (const n of snapshot.names) this.names.add(n);
+      }
+      if (snapshot.types && typeof snapshot.types === "object") {
+        for (const [key, val] of Object.entries(snapshot.types)) {
+          this.data.set(key, val);
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/storage/resolve.ts
+var currentConfig = {};
+var currentStorage = null;
+var storageFactory = async (config) => new MemoryStorage(config);
+function _setStorageFactory(factory) {
+  storageFactory = factory;
+}
+function configure(config) {
+  currentConfig = { ...currentConfig, ...config };
+  if (currentStorage) {
+    currentStorage.disconnect();
+    currentStorage = null;
+  }
+}
+function getConfig() {
+  return {
+    storage: currentConfig.storage ?? process.env.PROGRESSIVE_ZOD_STORAGE ?? "memory",
+    redisUrl: currentConfig.redisUrl ?? process.env.PROGRESSIVE_ZOD_REDIS_URL,
+    keyPrefix: currentConfig.keyPrefix ?? process.env.PROGRESSIVE_ZOD_KEY_PREFIX ?? "pzod:",
+    maxViolations: currentConfig.maxViolations ?? parseInt(process.env.PROGRESSIVE_ZOD_MAX_VIOLATIONS ?? "1000", 10),
+    maxSamples: currentConfig.maxSamples ?? parseInt(process.env.PROGRESSIVE_ZOD_MAX_SAMPLES ?? "1000", 10),
+    dataDir: currentConfig.dataDir ?? process.env.PROGRESSIVE_ZOD_DATA_DIR ?? ".progressive-zod"
+  };
+}
+async function getStorage() {
+  if (currentStorage) return currentStorage;
+  const config = getConfig();
+  currentStorage = await storageFactory(config, currentConfig);
+  return currentStorage;
+}
+
+// src/batch-processor.ts
+var DEFAULT_MAX_QUEUE_SIZE = 2048;
+var DEFAULT_FLUSH_INTERVAL_MS = 5e3;
+var DEFAULT_MAX_EXPORT_BATCH_SIZE = 512;
+var BatchProcessor = class {
+  queue = [];
+  timer = null;
+  flushing = false;
+  droppedCount = 0;
+  maxQueueSize;
+  flushIntervalMs;
+  maxExportBatchSize;
+  constructor(config = {}) {
+    this.maxQueueSize = config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+    this.flushIntervalMs = config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    this.maxExportBatchSize = config.maxExportBatchSize ?? DEFAULT_MAX_EXPORT_BATCH_SIZE;
+  }
+  /**
+   * Enqueue an observation. This is synchronous and fast — no I/O happens here.
+   * If the queue is full, the oldest observation is dropped (bounded memory).
+   */
+  enqueue(name, input, schema) {
+    this.ensureTimer();
+    let serialized;
+    try {
+      serialized = JSON.stringify(input);
+    } catch {
+      return;
+    }
+    if (this.queue.length >= this.maxQueueSize) {
+      this.queue.shift();
+      this.droppedCount++;
+    }
+    this.queue.push({ name, serialized, schema });
+    if (this.queue.length >= this.maxExportBatchSize) {
+      this.flushAsync();
+    }
+  }
+  /**
+   * Force flush all pending observations. Call during graceful shutdown.
+   */
+  async forceFlush() {
+    this.clearTimer();
+    await this.flush();
+  }
+  /**
+   * Shut down the processor: flush remaining data and stop the timer.
+   */
+  async shutdown() {
+    await this.forceFlush();
+  }
+  /** Number of observations currently in the queue */
+  get pendingCount() {
+    return this.queue.length;
+  }
+  /** Number of observations dropped due to queue overflow */
+  get dropped() {
+    return this.droppedCount;
+  }
+  ensureTimer() {
+    if (this.timer) return;
+    this.timer = setInterval(() => {
+      this.flushAsync();
+    }, this.flushIntervalMs);
+    if (this.timer && typeof this.timer === "object" && "unref" in this.timer) {
+      this.timer.unref();
+    }
+  }
+  clearTimer() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Non-blocking flush — errors are swallowed */
+  flushAsync() {
+    this.flush().catch(() => {
+    });
+  }
+  /** Drain the queue and send observations to storage in batch */
+  async flush() {
+    if (this.flushing || this.queue.length === 0) return;
+    this.flushing = true;
+    const batch = this.queue.splice(0, this.maxExportBatchSize);
+    try {
+      const storage = await getStorage();
+      await this.exportBatch(storage, batch);
+    } catch {
+    } finally {
+      this.flushing = false;
+      if (this.queue.length >= this.maxExportBatchSize) {
+        this.flushAsync();
+      }
+    }
+  }
+  async exportBatch(storage, batch) {
+    const names = /* @__PURE__ */ new Set();
+    for (const obs of batch) {
+      names.add(obs.name);
+    }
+    await Promise.all([...names].map((n) => storage.addName(n)));
+    const promises = [];
+    for (const obs of batch) {
+      promises.push(this.exportOne(storage, obs));
+    }
+    await Promise.all(promises);
+  }
+  async exportOne(storage, obs) {
+    await storage.addSample(obs.name, obs.serialized);
+    if (obs.schema) {
+      const result = obs.schema.safeParse(JSON.parse(obs.serialized));
+      if (result.success) {
+        await storage.incrConform(obs.name);
+      } else {
+        await storage.incrViolate(obs.name);
+        await storage.addViolation(obs.name, obs.serialized);
+      }
+    } else {
+      await storage.incrViolate(obs.name);
+      await storage.addViolation(obs.name, obs.serialized);
+    }
+  }
+};
+
+// src/progressive.ts
+var processor = null;
+function getProcessor() {
+  if (!processor) {
+    processor = new BatchProcessor();
+  }
+  return processor;
+}
+function configureBatch(config) {
+  if (processor) {
+    processor.forceFlush().catch(() => {
+    });
+  }
+  processor = new BatchProcessor(config);
+}
+async function forceFlush() {
+  if (processor) {
+    await processor.forceFlush();
+  }
+}
+async function shutdown() {
+  if (processor) {
+    await processor.shutdown();
+    processor = null;
+  }
+}
+function progressive(name, schema) {
+  return {
+    parse(input) {
+      getProcessor().enqueue(name, input, schema);
+      return input;
+    }
+  };
+}
+
+// src/storage/client.ts
+_setStorageFactory(async (config, userConfig) => {
+  if (config.storage === "amplitude") {
+    if (!userConfig.amplitudeClient) {
+      throw new Error(
+        "progressive-zod: storage is set to 'amplitude' but no amplitudeClient was provided. Pass an Amplitude client instance via configure({ amplitudeClient })."
+      );
+    }
+    const { AmplitudeStorage: AmplitudeStorage2 } = await Promise.resolve().then(() => (init_amplitude(), amplitude_exports));
+    return new AmplitudeStorage2(userConfig.amplitudeClient, config);
+  } else if (config.storage === "redis") {
+    throw new Error(
+      'progressive-zod: Redis storage is not available in the client bundle. Import from "progressive-zod" instead of "progressive-zod/client".'
+    );
+  }
+  return new MemoryStorage(config);
+});
+
+// src/infer-schema.ts
+var import_zod = require("zod");
+function inferSchema(samples) {
+  const objects = samples.filter(
+    (s) => typeof s === "object" && s !== null && !Array.isArray(s)
+  );
+  if (objects.length === 0) {
+    return inferPrimitiveUnion(samples);
+  }
+  const groups = groupByShape(objects);
+  if (groups.length === 1) {
+    return buildObjectSchema(groups[0]);
+  }
+  const discriminator = findDiscriminator(groups);
+  if (discriminator) {
+    return import_zod.z.discriminatedUnion(
+      discriminator,
+      groups.map(
+        (group) => buildObjectSchema(group)
+      )
+    );
+  }
+  return import_zod.z.union(
+    groups.map((group) => buildObjectSchema(group))
+  );
+}
+function shapeKey(obj) {
+  return Object.keys(obj).sort().join(",");
+}
+function groupByShape(objects) {
+  const map = /* @__PURE__ */ new Map();
+  for (const obj of objects) {
+    const key = shapeKey(obj);
+    let group = map.get(key);
+    if (!group) {
+      group = [];
+      map.set(key, group);
+    }
+    group.push(obj);
+  }
+  return [...map.values()];
+}
+function findDiscriminator(groups) {
+  if (groups.length < 2) return null;
+  const keySets = groups.map(
+    (g) => new Set(Object.keys(g[0]))
+  );
+  const commonKeys = [...keySets[0]].filter(
+    (k) => keySets.every((s) => s.has(k))
+  );
+  for (const key of commonKeys) {
+    const values = /* @__PURE__ */ new Set();
+    let valid = true;
+    for (const group of groups) {
+      const groupValues = new Set(
+        group.map((obj) => obj[key]).filter((v) => typeof v === "string")
+      );
+      if (groupValues.size !== 1) {
+        valid = false;
+        break;
+      }
+      const val = [...groupValues][0];
+      if (values.has(val)) {
+        valid = false;
+        break;
+      }
+      values.add(val);
+    }
+    if (valid && values.size === groups.length) {
+      return key;
+    }
+  }
+  return null;
+}
+function buildObjectSchema(samples) {
+  const keys = Object.keys(samples[0]);
+  const shape = {};
+  for (const key of keys) {
+    const values = samples.map((s) => s[key]);
+    const unique = new Set(values);
+    if (unique.size === 1 && typeof values[0] === "string") {
+      shape[key] = import_zod.z.literal(values[0]);
+    } else {
+      shape[key] = inferFieldType(values);
+    }
+  }
+  return import_zod.z.object(shape).strict();
+}
+function inferFieldType(values) {
+  const types = new Set(values.map(classifyValue));
+  if (types.size === 1) {
+    const type = [...types][0];
+    if (type === "string") return import_zod.z.string();
+    if (type === "number") return import_zod.z.number();
+    if (type === "boolean") return import_zod.z.boolean();
+    if (type === "null") return import_zod.z.null();
+    if (type === "object") {
+      return inferSchema(values);
+    }
+    if (type === "array") {
+      const allItems = values.flatMap(
+        (v) => Array.isArray(v) ? v : []
+      );
+      if (allItems.length === 0) return import_zod.z.array(import_zod.z.unknown());
+      return import_zod.z.array(inferFieldType(allItems));
+    }
+  }
+  if (types.size === 1 && types.has("string")) {
+    const unique = new Set(values);
+    if (unique.size === 1) {
+      return import_zod.z.literal(values[0]);
+    }
+  }
+  const members = [];
+  if (types.has("string")) members.push(import_zod.z.string());
+  if (types.has("number")) members.push(import_zod.z.number());
+  if (types.has("boolean")) members.push(import_zod.z.boolean());
+  if (types.has("null")) members.push(import_zod.z.null());
+  if (types.has("object")) {
+    const objs = values.filter(
+      (v) => typeof v === "object" && v !== null && !Array.isArray(v)
+    );
+    members.push(inferSchema(objs));
+  }
+  if (types.has("array")) {
+    const arrs = values.filter(Array.isArray);
+    const allItems = arrs.flat();
+    members.push(
+      import_zod.z.array(allItems.length > 0 ? inferFieldType(allItems) : import_zod.z.unknown())
+    );
+  }
+  if (members.length === 1) return members[0];
+  if (members.length === 2) return import_zod.z.union([members[0], members[1]]);
+  return import_zod.z.union(members);
+}
+function classifyValue(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function inferPrimitiveUnion(samples) {
+  const types = new Set(samples.map(classifyValue));
+  const members = [];
+  if (types.has("string")) members.push(import_zod.z.string());
+  if (types.has("number")) members.push(import_zod.z.number());
+  if (types.has("boolean")) members.push(import_zod.z.boolean());
+  if (types.has("null")) members.push(import_zod.z.null());
+  if (members.length === 0) return import_zod.z.unknown();
+  if (members.length === 1) return members[0];
+  return import_zod.z.union(members);
+}
+
+// src/schema-to-code.ts
+var import_zod2 = require("zod");
+function schemaToCode(schema, indent = 0) {
+  const pad = "  ".repeat(indent);
+  if (schema instanceof import_zod2.z.ZodString) return "z.string()";
+  if (schema instanceof import_zod2.z.ZodNumber) return "z.number()";
+  if (schema instanceof import_zod2.z.ZodBoolean) return "z.boolean()";
+  if (schema instanceof import_zod2.z.ZodNull) return "z.null()";
+  if (schema instanceof import_zod2.z.ZodUnknown) return "z.unknown()";
+  if (schema instanceof import_zod2.z.ZodLiteral) {
+    const val = schema.value;
+    return typeof val === "string" ? `z.literal("${val}")` : `z.literal(${val})`;
+  }
+  if (schema instanceof import_zod2.z.ZodArray) {
+    const inner = schemaToCode(schema.element, indent);
+    return `z.array(${inner})`;
+  }
+  if (schema instanceof import_zod2.z.ZodObject) {
+    const shape = schema.shape;
+    const keys = Object.keys(shape);
+    if (keys.length === 0) return "z.object({})";
+    const inner = pad + "  ";
+    const fields = keys.map(
+      (k) => `${inner}${safeProp(k)}: ${schemaToCode(shape[k], indent + 1)},`
+    );
+    const strict = schema._def && schema._def.unknownKeys === "strict" ? ".strict()" : "";
+    return `z.object({
+${fields.join("\n")}
+${pad}})${strict}`;
+  }
+  if (schema instanceof import_zod2.z.ZodUnion) {
+    const opts = schema.options;
+    const members = opts.map((o) => schemaToCode(o, indent));
+    if (members.every((m) => !m.includes("\n"))) {
+      return `z.union([${members.join(", ")}])`;
+    }
+    const inner = pad + "  ";
+    return `z.union([
+${members.map((m) => `${inner}${m},`).join("\n")}
+${pad}])`;
+  }
+  if (schema instanceof import_zod2.z.ZodDiscriminatedUnion) {
+    const disc = schema._def.discriminator;
+    const opts = schema._def.options;
+    const members = opts.map((o) => schemaToCode(o, indent + 1));
+    const inner = pad + "  ";
+    return `z.discriminatedUnion("${disc}", [
+${members.map((m) => `${inner}${m},`).join("\n")}
+${pad}])`;
+  }
+  return "z.unknown()";
+}
+function safeProp(key) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configure,
+  configureBatch,
+  forceFlush,
+  inferSchema,
+  progressive,
+  schemaToCode,
+  shutdown
+});
+//# sourceMappingURL=client.cjs.map