@qkitt/queue 0.1.0 → 0.1.1

package/dist/chunk-R2ONNABJ.js

@@ -0,0 +1,531 @@
+import { createMemorySnapshotStore, createWebSnapshotStore, createLocalStorageSnapshotStore, createSessionStorageSnapshotStore, createMemoryRowStore, createWebRowStore, createLocalStorageRowStore, createSessionStorageRowStore } from './chunk-SMQYICXZ.js';
+import { buildQueue, withSnapshotPersist, withRowPersist, withWorker } from './chunk-653YYS22.js';
+import { buildRouter } from './chunk-WIKDEC7T.js';
+
+// src/config/config-freeze.util.ts
+var freezeConfig = (config) => {
+  const queues = {};
+  for (const [name, queue] of Object.entries(config.queues)) {
+    queues[name] = Object.freeze({ ...queue });
+  }
+  const stores = {};
+  if (config.stores) {
+    for (const [name, store] of Object.entries(config.stores)) {
+      stores[name] = Object.freeze({ ...store });
+    }
+  }
+  const frozen = {
+    ...config,
+    ...Object.keys(stores).length > 0 ? { stores: Object.freeze(stores) } : {},
+    queues: Object.freeze(queues),
+    ...config.router ? {
+      router: Object.freeze({
+        ...config.router,
+        ...config.router.bindings ? {
+          bindings: Object.freeze(
+            config.router.bindings.map(
+              (b) => Object.freeze({ ...b })
+            )
+          )
+        } : {},
+        ...config.router.unmatchedQueue !== void 0 ? { unmatchedQueue: config.router.unmatchedQueue } : {}
+      })
+    } : {}
+  };
+  return Object.freeze(frozen);
+};
+
+// src/config/store-resolve.util.ts
+var isWebAdapter = (adapter) => adapter === "localStorage" || adapter === "sessionStorage";
+var isSnapshotStore = (value) => typeof value.load === "function" && typeof value.save === "function";
+var isRowStore = (value) => {
+  const store = value;
+  return typeof store.loadAll === "function" && typeof store.insert === "function" && typeof store.remove === "function" && typeof store.clear === "function";
+};
+var createBuiltinSnapshot = (storeName, adapter, key, options) => {
+  if (adapter === "memory") {
+    return createMemorySnapshotStore();
+  }
+  if (key === void 0 || key.length === 0) {
+    throw new Error(
+      `config.stores.${storeName}.key is required when adapter is "${adapter}"`
+    );
+  }
+  if (options.storage) {
+    return createWebSnapshotStore({
+      key,
+      storage: options.storage
+    });
+  }
+  if (adapter === "localStorage") {
+    return createLocalStorageSnapshotStore(key);
+  }
+  return createSessionStorageSnapshotStore(key);
+};
+var createBuiltinRow = (storeName, adapter, key, options) => {
+  if (adapter === "memory") {
+    return createMemoryRowStore();
+  }
+  if (key === void 0 || key.length === 0) {
+    throw new Error(
+      `config.stores.${storeName}.key is required when adapter is "${adapter}"`
+    );
+  }
+  if (options.storage) {
+    return createWebRowStore({
+      key,
+      storage: options.storage
+    });
+  }
+  if (adapter === "localStorage") {
+    return createLocalStorageRowStore(key);
+  }
+  return createSessionStorageRowStore(key);
+};
+var resolveStore = (storeName, definition, options) => {
+  if ("impl" in definition) {
+    const impl = definition.impl;
+    if (definition.strategy === "snapshot" && !isSnapshotStore(impl)) {
+      throw new Error(
+        `config.stores.${storeName}.impl must be a SnapshotStore (strategy is "snapshot")`
+      );
+    }
+    if (definition.strategy === "row" && !isRowStore(impl)) {
+      throw new Error(
+        `config.stores.${storeName}.impl must be a RowStore (strategy is "row")`
+      );
+    }
+    return impl;
+  }
+  const { adapter, strategy } = definition;
+  const key = definition.key;
+  if (isWebAdapter(adapter) && (key === void 0 || key.length === 0)) {
+    throw new Error(
+      `config.stores.${storeName}.key is required when adapter is "${adapter}"`
+    );
+  }
+  if (strategy === "snapshot") {
+    return createBuiltinSnapshot(storeName, adapter, key, options);
+  }
+  return createBuiltinRow(storeName, adapter, key, options);
+};
+var resolveAllStores = (stores, options) => {
+  const resolved = {};
+  if (!stores) return resolved;
+  for (const [name, definition] of Object.entries(stores)) {
+    resolved[name] = resolveStore(name, definition, options);
+  }
+  return resolved;
+};
+
+// src/config/parse.util.ts
+var BUILTIN_ADAPTERS = /* @__PURE__ */ new Set([
+  "memory",
+  "localStorage",
+  "sessionStorage"
+]);
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var expectString = (value, path) => {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${path} must be a non-empty string`);
+  }
+  return value;
+};
+var expectBoolean = (value, path) => {
+  if (typeof value !== "boolean") {
+    throw new Error(`${path} must be a boolean`);
+  }
+  return value;
+};
+var expectPositiveFinite = (value, path) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 1) {
+    throw new Error(`${path} must be a finite number >= 1`);
+  }
+  return value;
+};
+var parseAdapter = (value, path) => {
+  if (typeof value !== "string" || !BUILTIN_ADAPTERS.has(value)) {
+    throw new Error(
+      `${path} must be one of: memory, localStorage, sessionStorage`
+    );
+  }
+  return value;
+};
+var isSnapshotStoreLike = (value) => isPlainObject(value) && typeof value.load === "function" && typeof value.save === "function";
+var isRowStoreLike = (value) => isPlainObject(value) && typeof value.loadAll === "function" && typeof value.insert === "function" && typeof value.remove === "function" && typeof value.clear === "function";
+var parseStrategy = (value, path) => {
+  if (value !== "snapshot" && value !== "row") {
+    throw new Error(`${path} must be "snapshot" or "row"`);
+  }
+  return value;
+};
+
+// src/config/validate.ts
+var parseStoreDefinition = (value, path, { allowJs }) => {
+  if (!isPlainObject(value)) {
+    throw new Error(`${path} must be an object`);
+  }
+  const strategy = parseStrategy(value.strategy, `${path}.strategy`);
+  if (value.impl !== void 0) {
+    if (!allowJs) {
+      throw new Error(
+        `${path}.impl is only valid in JS config (not JSON); implement SnapshotStore/RowStore and pass the instance from a module`
+      );
+    }
+    if (value.adapter !== void 0) {
+      throw new Error(
+        `${path} cannot set both "adapter" and "impl"`
+      );
+    }
+    if (strategy === "snapshot") {
+      if (!isSnapshotStoreLike(value.impl)) {
+        throw new Error(
+          `${path}.impl must be a SnapshotStore (load + save)`
+        );
+      }
+      return {
+        strategy: "snapshot",
+        impl: value.impl
+      };
+    }
+    if (!isRowStoreLike(value.impl)) {
+      throw new Error(
+        `${path}.impl must be a RowStore (loadAll + insert + remove + clear)`
+      );
+    }
+    return {
+      strategy: "row",
+      impl: value.impl
+    };
+  }
+  if (value.adapter === void 0) {
+    throw new Error(
+      `${path} must define "adapter" (built-in) or "impl" (custom store)`
+    );
+  }
+  const adapter = parseAdapter(value.adapter, `${path}.adapter`);
+  const key = value.key === void 0 ? void 0 : expectString(value.key, `${path}.key`);
+  if ((adapter === "localStorage" || adapter === "sessionStorage") && (key === void 0 || key.length === 0)) {
+    throw new Error(
+      `${path}.key is required when adapter is "${adapter}"`
+    );
+  }
+  if (strategy === "snapshot") {
+    return {
+      strategy: "snapshot",
+      adapter,
+      ...key !== void 0 ? { key } : {}
+    };
+  }
+  return {
+    strategy: "row",
+    adapter,
+    ...key !== void 0 ? { key } : {}
+  };
+};
+var parsePersistConfig = (value, path, storeNames) => {
+  if (!isPlainObject(value)) {
+    throw new Error(`${path} must be an object`);
+  }
+  const store = expectString(value.store, `${path}.store`);
+  if (!storeNames.has(store)) {
+    throw new Error(
+      `${path}.store "${store}" is not defined in config.stores`
+    );
+  }
+  const autoSave = value.autoSave === void 0 ? void 0 : expectBoolean(value.autoSave, `${path}.autoSave`);
+  return {
+    store,
+    ...autoSave !== void 0 ? { autoSave } : {}
+  };
+};
+var parseWorkerConfig = (value, path) => {
+  if (typeof value === "function") {
+    return value;
+  }
+  if (!isPlainObject(value)) {
+    throw new Error(
+      `${path} must be a function or { run, concurrency?, autoStart? }`
+    );
+  }
+  if (typeof value.run !== "function") {
+    throw new Error(`${path}.run must be a function`);
+  }
+  const concurrency = value.concurrency === void 0 ? void 0 : expectPositiveFinite(value.concurrency, `${path}.concurrency`);
+  const autoStart = value.autoStart === void 0 ? void 0 : expectBoolean(value.autoStart, `${path}.autoStart`);
+  return {
+    run: value.run,
+    ...concurrency !== void 0 ? { concurrency } : {},
+    ...autoStart !== void 0 ? { autoStart } : {}
+  };
+};
+var parseQueueConfig = (value, path, storeNames, { allowJs }) => {
+  if (!isPlainObject(value)) {
+    throw new Error(`${path} must be an object`);
+  }
+  const queue = {};
+  if (value.maxSize !== void 0) {
+    queue.maxSize = expectPositiveFinite(value.maxSize, `${path}.maxSize`);
+  }
+  if (value.persist !== void 0) {
+    queue.persist = parsePersistConfig(
+      value.persist,
+      `${path}.persist`,
+      storeNames
+    );
+  }
+  if (value.worker !== void 0) {
+    if (!allowJs) {
+      throw new Error(
+        `${path}.worker is only valid in JS config (functions cannot be expressed in JSON)`
+      );
+    }
+    queue.worker = parseWorkerConfig(value.worker, `${path}.worker`);
+  }
+  return queue;
+};
+var parseBindingConfig = (value, path) => {
+  if (!isPlainObject(value)) {
+    throw new Error(`${path} must be an object`);
+  }
+  return {
+    pattern: expectString(value.pattern, `${path}.pattern`),
+    queue: expectString(value.queue, `${path}.queue`)
+  };
+};
+var parseRouterConfig = (value, path) => {
+  if (!isPlainObject(value)) {
+    throw new Error(`${path} must be an object`);
+  }
+  const router = {};
+  if (value.bindings !== void 0) {
+    if (!Array.isArray(value.bindings)) {
+      throw new Error(`${path}.bindings must be an array`);
+    }
+    router.bindings = value.bindings.map(
+      (binding, index) => parseBindingConfig(binding, `${path}.bindings[${index}]`)
+    );
+  }
+  if (value.unmatchedQueue !== void 0) {
+    router.unmatchedQueue = expectString(
+      value.unmatchedQueue,
+      `${path}.unmatchedQueue`
+    );
+  }
+  return router;
+};
+var parseSystemConfigValue = (value, options) => {
+  if (!isPlainObject(value)) {
+    throw new Error("config must be an object");
+  }
+  if (!isPlainObject(value.queues)) {
+    throw new Error("config.queues must be an object");
+  }
+  const queueNames = Object.keys(value.queues);
+  if (queueNames.length === 0) {
+    throw new Error("config.queues must define at least one queue");
+  }
+  const stores = {};
+  if (value.stores !== void 0) {
+    if (!isPlainObject(value.stores)) {
+      throw new Error("config.stores must be an object");
+    }
+    for (const name of Object.keys(value.stores)) {
+      if (name.length === 0) {
+        throw new Error("config.stores keys must be non-empty strings");
+      }
+      stores[name] = parseStoreDefinition(
+        value.stores[name],
+        `config.stores.${name}`,
+        { allowJs: options.allowJs }
+      );
+    }
+  }
+  const storeNames = new Set(Object.keys(stores));
+  const queues = {};
+  for (const name of queueNames) {
+    if (name.length === 0) {
+      throw new Error("config.queues keys must be non-empty strings");
+    }
+    queues[name] = parseQueueConfig(
+      value.queues[name],
+      `config.queues.${name}`,
+      storeNames,
+      { allowJs: options.allowJs }
+    );
+  }
+  const config = { queues };
+  if (Object.keys(stores).length > 0) {
+    config.stores = stores;
+  }
+  if (value.router !== void 0) {
+    config.router = parseRouterConfig(value.router, "config.router");
+  }
+  if (value.hydrate !== void 0) {
+    config.hydrate = expectBoolean(value.hydrate, "config.hydrate");
+  }
+  if (config.router?.bindings) {
+    for (const [index, binding] of config.router.bindings.entries()) {
+      if (!(binding.queue in queues)) {
+        throw new Error(
+          `config.router.bindings[${index}].queue "${binding.queue}" is not defined in config.queues`
+        );
+      }
+    }
+  }
+  if (config.router?.unmatchedQueue !== void 0) {
+    if (!(config.router.unmatchedQueue in queues)) {
+      throw new Error(
+        `config.router.unmatchedQueue "${config.router.unmatchedQueue}" is not defined in config.queues`
+      );
+    }
+  }
+  return config;
+};
+var validateSystemConfig = (value) => parseSystemConfigValue(value, { allowJs: false });
+var validateJsConfig = (value) => parseSystemConfigValue(value, { allowJs: true });
+var defineConfig = (config) => validateJsConfig(config);
+var parseSystemConfig = (json) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "invalid JSON";
+    throw new Error(`config JSON is invalid: ${message}`);
+  }
+  return validateSystemConfig(parsed);
+};
+
+// src/config/from-config.ts
+var resolveWorker = (worker) => {
+  if (typeof worker === "function") {
+    return { run: worker, options: {} };
+  }
+  const { run, concurrency, autoStart } = worker;
+  return {
+    run,
+    options: {
+      ...concurrency !== void 0 ? { concurrency } : {},
+      ...autoStart !== void 0 ? { autoStart } : {}
+    }
+  };
+};
+var buildQueueFromConfig = (queueName, queueConfig, storeDefs, resolvedStores) => {
+  let queue = buildQueue(
+    queueConfig.maxSize !== void 0 ? { maxSize: queueConfig.maxSize } : {}
+  );
+  if (queueConfig.persist) {
+    const storeName = queueConfig.persist.store;
+    const definition = storeDefs?.[storeName];
+    const store = resolvedStores[storeName];
+    if (!definition || !store) {
+      throw new Error(
+        `config.queues.${queueName}.persist.store "${storeName}" is not defined in config.stores`
+      );
+    }
+    if (definition.strategy === "snapshot") {
+      if (!isSnapshotStore(store)) {
+        throw new Error(
+          `config.stores.${storeName} is not a SnapshotStore`
+        );
+      }
+      queue = withSnapshotPersist(queue, store, {
+        autoSave: queueConfig.persist.autoSave
+      });
+    } else {
+      if (!isRowStore(store)) {
+        throw new Error(
+          `config.stores.${storeName} is not a RowStore`
+        );
+      }
+      queue = withRowPersist(queue, store);
+    }
+  }
+  if (queueConfig.worker) {
+    const { run, options: workerOptions } = resolveWorker(queueConfig.worker);
+    queue = withWorker(queue, run, workerOptions);
+  }
+  return queue;
+};
+var buildFromConfig = async (config, options = {}) => {
+  const validated = validateJsConfig(config);
+  const resolvedStores = resolveAllStores(validated.stores, options);
+  const queues = {};
+  for (const [name, queueConfig] of Object.entries(validated.queues)) {
+    queues[name] = buildQueueFromConfig(
+      name,
+      queueConfig,
+      validated.stores,
+      resolvedStores
+    );
+  }
+  let router;
+  if (validated.router) {
+    const queueMap = queues;
+    let unmatchedTarget;
+    if (validated.router.unmatchedQueue !== void 0) {
+      const sink = queueMap[validated.router.unmatchedQueue];
+      if (!sink) {
+        throw new Error(
+          `router unmatchedQueue "${validated.router.unmatchedQueue}" is not defined`
+        );
+      }
+      unmatchedTarget = sink;
+    }
+    const built = buildRouter(
+      unmatchedTarget !== void 0 ? { unmatchedTarget } : {}
+    );
+    for (const binding of validated.router.bindings ?? []) {
+      const target = queueMap[binding.queue];
+      if (!target) {
+        throw new Error(
+          `router binding queue "${binding.queue}" is not defined`
+        );
+      }
+      built.bind(binding.pattern, target);
+    }
+    router = built;
+  }
+  const hydrateAll = async () => {
+    const tasks = [];
+    for (const queue of Object.values(
+      queues
+    )) {
+      if (typeof queue.hydrate === "function") {
+        tasks.push(queue.hydrate());
+      }
+    }
+    await Promise.all(tasks);
+  };
+  const flushAll = async () => {
+    const tasks = [];
+    for (const queue of Object.values(
+      queues
+    )) {
+      if (typeof queue.flush === "function") {
+        tasks.push(queue.flush());
+      }
+    }
+    await Promise.all(tasks);
+  };
+  const shouldHydrate = validated.hydrate ?? Object.values(validated.queues).some((q) => q.persist !== void 0);
+  if (shouldHydrate) {
+    await hydrateAll();
+  }
+  return {
+    queues,
+    stores: resolvedStores,
+    router,
+    hydrateAll,
+    flushAll,
+    config: freezeConfig(validated)
+  };
+};
+var buildFromJson = async (json, options = {}) => {
+  const config = parseSystemConfig(json);
+  return buildFromConfig(config, options);
+};
+
+export { buildFromConfig, buildFromJson, defineConfig, parseSystemConfig, validateJsConfig, validateSystemConfig };
+//# sourceMappingURL=chunk-R2ONNABJ.js.map
+//# sourceMappingURL=chunk-R2ONNABJ.js.map