zen-code 1.0.0

package/dist/postgres-dialect-DaHvQ_AZ.mjs

@@ -0,0 +1,211 @@
+import { aS as p, ah as h, F as r, bb as l, bi as d, bc as y, bj as w, c } from "./sql-CJsUpKEQ.mjs";
+import { D as g, b as _, c as f, a as b, C as o } from "./migrator-BatO36Tk.mjs";
+function i(n, e) {
+  return p.createWithChildren([
+    p.createWithSql(`${n} `),
+    h.create(e)
+    // ensures savepointName gets sanitized
+  ]);
+}
+const T = /"/g;
+class E extends g {
+  sanitizeIdentifier(e) {
+    return e.replace(T, '""');
+  }
+}
+class C {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  async getSchemas() {
+    return (await this.#e.selectFrom("pg_catalog.pg_namespace").select("nspname").$castTo().execute()).map((a) => ({ name: a.nspname }));
+  }
+  async getTables(e = { withInternalKyselyTables: !1 }) {
+    let a = this.#e.selectFrom("pg_catalog.pg_attribute as a").innerJoin("pg_catalog.pg_class as c", "a.attrelid", "c.oid").innerJoin("pg_catalog.pg_namespace as ns", "c.relnamespace", "ns.oid").innerJoin("pg_catalog.pg_type as typ", "a.atttypid", "typ.oid").innerJoin("pg_catalog.pg_namespace as dtns", "typ.typnamespace", "dtns.oid").select([
+      "a.attname as column",
+      "a.attnotnull as not_null",
+      "a.atthasdef as has_default",
+      "c.relname as table",
+      "c.relkind as table_type",
+      "ns.nspname as schema",
+      "typ.typname as type",
+      "dtns.nspname as type_schema",
+      r`col_description(a.attrelid, a.attnum)`.as("column_description"),
+      r`pg_get_serial_sequence(quote_ident(ns.nspname) || '.' || quote_ident(c.relname), a.attname)`.as("auto_incrementing")
+    ]).where("c.relkind", "in", [
+      "r",
+      "v",
+      "p"
+    ]).where("ns.nspname", "!~", "^pg_").where("ns.nspname", "!=", "information_schema").where("ns.nspname", "!=", "crdb_internal").where(r`has_schema_privilege(ns.nspname, 'USAGE')`).where("a.attnum", ">=", 0).where("a.attisdropped", "!=", !0).orderBy("ns.nspname").orderBy("c.relname").orderBy("a.attnum").$castTo();
+    e.withInternalKyselyTables || (a = a.where("c.relname", "!=", _).where("c.relname", "!=", f));
+    const t = await a.execute();
+    return this.#a(t);
+  }
+  async getMetadata(e) {
+    return {
+      tables: await this.getTables(e)
+    };
+  }
+  #a(e) {
+    return e.reduce((a, t) => {
+      let s = a.find((u) => u.name === t.table && u.schema === t.schema);
+      return s || (s = l({
+        name: t.table,
+        isView: t.table_type === "v",
+        schema: t.schema,
+        columns: []
+      }), a.push(s)), s.columns.push(l({
+        name: t.column,
+        dataType: t.type,
+        dataTypeSchema: t.type_schema,
+        isNullable: !t.not_null,
+        isAutoIncrementing: t.auto_incrementing !== null,
+        hasDefaultValue: t.has_default,
+        comment: t.column_description ?? void 0
+      })), a;
+    }, []);
+  }
+}
+const I = BigInt("3853314791062309107");
+class k extends b {
+  get supportsTransactionalDdl() {
+    return !0;
+  }
+  get supportsReturning() {
+    return !0;
+  }
+  async acquireMigrationLock(e, a) {
+    await r`select pg_advisory_xact_lock(${r.lit(I)})`.execute(e);
+  }
+  async releaseMigrationLock(e, a) {
+  }
+}
+function v(n, e) {
+  if (x(n) && e.stack) {
+    const a = e.stack.split(`
+`).slice(1).join(`
+`);
+    return n.stack += `
+${a}`, n;
+  }
+  return n;
+}
+function x(n) {
+  return d(n) && y(n.stack);
+}
+const m = /* @__PURE__ */ Symbol();
+class A {
+  #e;
+  #a = /* @__PURE__ */ new WeakMap();
+  #t;
+  constructor(e) {
+    this.#e = l({ ...e });
+  }
+  async init() {
+    this.#t = w(this.#e.pool) ? await this.#e.pool() : this.#e.pool;
+  }
+  async acquireConnection() {
+    const e = await this.#t.connect();
+    let a = this.#a.get(e);
+    return a || (a = new D(e, {
+      cursor: this.#e.cursor ?? null
+    }), this.#a.set(e, a), this.#e.onCreateConnection && await this.#e.onCreateConnection(a)), this.#e.onReserveConnection && await this.#e.onReserveConnection(a), a;
+  }
+  async beginTransaction(e, a) {
+    if (a.isolationLevel || a.accessMode) {
+      let t = "start transaction";
+      a.isolationLevel && (t += ` isolation level ${a.isolationLevel}`), a.accessMode && (t += ` ${a.accessMode}`), await e.executeQuery(o.raw(t));
+    } else
+      await e.executeQuery(o.raw("begin"));
+  }
+  async commitTransaction(e) {
+    await e.executeQuery(o.raw("commit"));
+  }
+  async rollbackTransaction(e) {
+    await e.executeQuery(o.raw("rollback"));
+  }
+  async savepoint(e, a, t) {
+    await e.executeQuery(t(i("savepoint", a), c()));
+  }
+  async rollbackToSavepoint(e, a, t) {
+    await e.executeQuery(t(i("rollback to", a), c()));
+  }
+  async releaseSavepoint(e, a, t) {
+    await e.executeQuery(t(i("release", a), c()));
+  }
+  async releaseConnection(e) {
+    e[m]();
+  }
+  async destroy() {
+    if (this.#t) {
+      const e = this.#t;
+      this.#t = void 0, await e.end();
+    }
+  }
+}
+class D {
+  #e;
+  #a;
+  constructor(e, a) {
+    this.#e = e, this.#a = a;
+  }
+  async executeQuery(e) {
+    try {
+      const { command: a, rowCount: t, rows: s } = await this.#e.query(e.sql, [...e.parameters]);
+      return {
+        numAffectedRows: a === "INSERT" || a === "UPDATE" || a === "DELETE" || a === "MERGE" ? BigInt(t) : void 0,
+        rows: s ?? []
+      };
+    } catch (a) {
+      throw v(a, new Error());
+    }
+  }
+  async *streamQuery(e, a) {
+    if (!this.#a.cursor)
+      throw new Error("'cursor' is not present in your postgres dialect config. It's required to make streaming work in postgres.");
+    if (!Number.isInteger(a) || a <= 0)
+      throw new Error("chunkSize must be a positive integer");
+    const t = this.#e.query(new this.#a.cursor(e.sql, e.parameters.slice()));
+    try {
+      for (; ; ) {
+        const s = await t.read(a);
+        if (s.length === 0)
+          break;
+        yield {
+          rows: s
+        };
+      }
+    } finally {
+      await t.close();
+    }
+  }
+  [m]() {
+    this.#e.release();
+  }
+}
+class L {
+  #e;
+  constructor(e) {
+    this.#e = e;
+  }
+  createDriver() {
+    return new A(this.#e);
+  }
+  createQueryCompiler() {
+    return new E();
+  }
+  createAdapter() {
+    return new k();
+  }
+  createIntrospector(e) {
+    return new C(e);
+  }
+}
+export {
+  E as P,
+  C as a,
+  k as b,
+  A as c,
+  L as d
+};

package/dist/queue-BSCnCent-Dtq-TPST.mjs

@@ -0,0 +1,81 @@
+import { a as u, C as h } from "./app-CV_FJyjI.mjs";
+import { createClient as n } from "redis";
+class r extends u {
+  constructor(s, e = !0, i = 300) {
+    super(s, !0, i), this.id = s, this.compressMessages = e, this.ttl = i, this.queueKey = `queue:${this.id}`, this.channelKey = `channel:${this.id}`, this.redis = r.redis, this.subscriberRedis = r.subscriberRedis, this.cancelSignal = new AbortController(), this.redis.isOpen || this.redis.connect(), this.subscriberRedis.isOpen || this.subscriberRedis.connect(), this.isConnected = !0;
+  }
+  static redis = n({ url: process.env.REDIS_URL });
+  static subscriberRedis = n({ url: process.env.REDIS_URL });
+  static isQueueExist(s) {
+    return this.redis.exists(`queue:${s}`).then((e) => e > 0);
+  }
+  redis;
+  subscriberRedis;
+  queueKey;
+  channelKey;
+  isConnected = !1;
+  cancelSignal;
+  /**
+   * 推送消息到 Redis 队列
+   */
+  async push(s) {
+    const e = await this.encodeData(s), i = Buffer.from(e);
+    await this.redis.rPush(this.queueKey, i), await this.redis.expire(this.queueKey, this.ttl), await this.redis.publish(this.channelKey, i), this.emit("dataChange", e);
+  }
+  /**
+   * 异步生成器：支持 for await...of 方式消费队列数据
+   */
+  async *onDataReceive() {
+    let s = [], e = null, i = !1;
+    const c = async (t) => {
+      const a = await this.decodeData(t);
+      s.push(a), (a.event === "__stream_end__" || a.event === "__stream_error__" || a.event === "__stream_cancel__") && (setTimeout(() => {
+        i = !0, e && (e(), e = null);
+      }, 300), a.event === "__stream_cancel__" && this.cancel()), e && (e(), e = null);
+    };
+    await this.subscriberRedis.subscribe(this.channelKey, (t) => {
+      c(t);
+    });
+    try {
+      for (; !i; )
+        if (s.length > 0) {
+          for (const t of s)
+            yield t;
+          s = [];
+        } else
+          await new Promise((t) => {
+            e = t;
+          });
+    } finally {
+      await this.subscriberRedis.unsubscribe(this.channelKey);
+    }
+  }
+  /**
+   * 获取队列中的所有数据
+   */
+  async getAll() {
+    const s = await this.redis.lRange(this.queueKey, 0, -1);
+    return !s || s.length === 0 ? [] : this.compressMessages ? await Promise.all(
+      s.map((e) => this.decodeData(e))
+    ) : s.map((e) => JSON.parse(e));
+  }
+  /**
+   * 清空队列
+   */
+  clear() {
+    this.isConnected && this.redis.del(this.queueKey);
+  }
+  /**
+   * 取消操作
+   */
+  cancel() {
+    this.push(new h()), this.cancelSignal.abort("user cancel this run");
+  }
+  async copyToQueue(s, e) {
+    const i = new r(s, this.compressMessages, e ?? this.ttl);
+    return await this.redis.copy(this.queueKey, i.queueKey), await this.redis.expire(i.queueKey, e ?? this.ttl), i;
+  }
+}
+export {
+  r as RedisStreamQueue
+};

package/dist/shallow-BKrykESK.mjs

@@ -0,0 +1,330 @@
+import { B as $, u as g } from "./app-CV_FJyjI.mjs";
+import { createClient as T } from "redis";
+function k(u) {
+  if (u === null || typeof u != "object") return JSON.stringify(u);
+  if (Array.isArray(u)) return JSON.stringify(u.map((i) => k(i)));
+  const t = {}, e = Object.keys(u).sort();
+  for (const i of e) t[i] = u[i];
+  return JSON.stringify(t, (i, n) => {
+    if (n !== null && typeof n == "object" && !Array.isArray(n)) {
+      const s = {}, c = Object.keys(n).sort();
+      for (const r of c) s[r] = n[r];
+      return s;
+    }
+    return n;
+  });
+}
+const S = [{
+  index: "checkpoints",
+  prefix: "checkpoint:",
+  schema: {
+    "$.thread_id": {
+      type: "TAG",
+      AS: "thread_id"
+    },
+    "$.checkpoint_ns": {
+      type: "TAG",
+      AS: "checkpoint_ns"
+    },
+    "$.checkpoint_id": {
+      type: "TAG",
+      AS: "checkpoint_id"
+    },
+    "$.parent_checkpoint_id": {
+      type: "TAG",
+      AS: "parent_checkpoint_id"
+    },
+    "$.checkpoint_ts": {
+      type: "NUMERIC",
+      AS: "checkpoint_ts"
+    },
+    "$.has_writes": {
+      type: "TAG",
+      AS: "has_writes"
+    },
+    "$.source": {
+      type: "TAG",
+      AS: "source"
+    },
+    "$.step": {
+      type: "NUMERIC",
+      AS: "step"
+    }
+  }
+}, {
+  index: "checkpoint_writes",
+  prefix: "checkpoint_write:",
+  schema: {
+    "$.thread_id": {
+      type: "TAG",
+      AS: "thread_id"
+    },
+    "$.checkpoint_ns": {
+      type: "TAG",
+      AS: "checkpoint_ns"
+    },
+    "$.checkpoint_id": {
+      type: "TAG",
+      AS: "checkpoint_id"
+    },
+    "$.task_id": {
+      type: "TAG",
+      AS: "task_id"
+    },
+    "$.idx": {
+      type: "NUMERIC",
+      AS: "idx"
+    },
+    "$.channel": {
+      type: "TAG",
+      AS: "channel"
+    },
+    "$.type": {
+      type: "TAG",
+      AS: "type"
+    }
+  }
+}];
+var x = class w extends $ {
+  client;
+  ttlConfig;
+  constructor(t, e) {
+    super(), this.client = t, this.ttlConfig = e;
+  }
+  static async fromUrl(t, e) {
+    const i = T({ url: t });
+    await i.connect();
+    const n = new w(i, e);
+    return await n.ensureIndexes(), n;
+  }
+  async get(t) {
+    return (await this.getTuple(t))?.checkpoint;
+  }
+  async put(t, e, i, n) {
+    await this.ensureIndexes();
+    const s = t.configurable?.thread_id, c = t.configurable?.checkpoint_ns ?? "", r = t.configurable?.checkpoint_id;
+    if (!s) throw new Error("thread_id is required");
+    const a = e.id || g(0), l = `checkpoint:${s}:${c}:shallow`;
+    let h = null, p = null;
+    try {
+      h = await this.client.json.get(l), h && typeof h == "object" && (p = h.checkpoint_id);
+    } catch {
+    }
+    p && p !== a && await this.cleanupOldCheckpoint(s, c, p);
+    const o = {
+      ...e,
+      channel_values: e.channel_values || {},
+      channel_blobs: void 0
+    }, d = {
+      thread_id: s,
+      checkpoint_ns: c,
+      checkpoint_id: a,
+      parent_checkpoint_id: r || null,
+      checkpoint: o,
+      metadata: this.sanitizeMetadata(i),
+      checkpoint_ts: Date.now(),
+      has_writes: "false"
+    };
+    return this.addSearchableMetadataFields(d, i), await this.client.json.set(l, "$", d), this.ttlConfig?.defaultTTL && await this.applyTTL(l), { configurable: {
+      thread_id: s,
+      checkpoint_ns: c,
+      checkpoint_id: a
+    } };
+  }
+  async getTuple(t) {
+    const e = t.configurable?.thread_id, i = t.configurable?.checkpoint_ns ?? "", n = t.configurable?.checkpoint_id;
+    if (!e) return;
+    const s = `checkpoint:${e}:${i}:shallow`, c = await this.client.json.get(s);
+    if (!c || n && c.checkpoint_id !== n) return;
+    this.ttlConfig?.refreshOnRead && this.ttlConfig?.defaultTTL && await this.applyTTL(s);
+    const r = await this.serde.loadsTyped("json", JSON.stringify(c.checkpoint));
+    let a;
+    return c.has_writes === "true" && (a = await this.loadPendingWrites(c.thread_id, c.checkpoint_ns, c.checkpoint_id)), await this.createCheckpointTuple(c, r, a);
+  }
+  async *list(t, e) {
+    if (await this.ensureIndexes(), t?.configurable?.thread_id) {
+      const i = await this.getTuple(t);
+      i && (e?.filter ? this.checkMetadataFilterMatch(i.metadata, e.filter) && (yield i) : yield i);
+    } else {
+      const i = [];
+      if (e?.filter)
+        for (const [c, r] of Object.entries(e.filter)) r === void 0 || r === null || (typeof r == "string" ? i.push(`(@${c}:{${r}})`) : typeof r == "number" && i.push(`(@${c}:[${r} ${r}])`));
+      i.length === 0 && i.push("*");
+      const n = i.join(" "), s = e?.limit ?? 10;
+      try {
+        const c = await this.client.ft.search("checkpoints", n, {
+          LIMIT: {
+            from: 0,
+            size: s * 2
+          },
+          SORTBY: {
+            BY: "checkpoint_ts",
+            DIRECTION: "DESC"
+          }
+        }), r = /* @__PURE__ */ new Set();
+        let a = 0;
+        for (const l of c.documents) {
+          if (a >= s) break;
+          const h = l.value, p = `${h.thread_id}:${h.checkpoint_ns}`;
+          if (r.has(p) || (r.add(p), e?.filter && !this.checkMetadataFilterMatch(h.metadata, e.filter)))
+            continue;
+          const o = await this.serde.loadsTyped("json", JSON.stringify(h.checkpoint));
+          yield await this.createCheckpointTuple(h, o), a++;
+        }
+      } catch (c) {
+        if (c.message?.includes("no such index")) {
+          const a = await this.client.keys("checkpoint:*:*:shallow");
+          if (a.length === 0) return;
+          a.sort().reverse();
+          const l = /* @__PURE__ */ new Set();
+          let h = 0;
+          const p = e?.limit ?? 10;
+          for (const o of a) {
+            if (h >= p) break;
+            const d = await this.client.json.get(o);
+            if (!d) continue;
+            const f = `${d.thread_id}:${d.checkpoint_ns}`;
+            if (l.has(f) || (l.add(f), e?.filter && !this.checkMetadataFilterMatch(d.metadata, e.filter)))
+              continue;
+            const y = await this.serde.loadsTyped("json", JSON.stringify(d.checkpoint));
+            yield await this.createCheckpointTuple(d, y), h++;
+          }
+          return;
+        }
+        throw c;
+      }
+    }
+  }
+  async putWrites(t, e, i) {
+    await this.ensureIndexes();
+    const n = t.configurable?.thread_id, s = t.configurable?.checkpoint_ns ?? "", c = t.configurable?.checkpoint_id;
+    if (!n || !c) throw new Error("thread_id and checkpoint_id are required");
+    const r = `checkpoint_write:${n}:${s}:${c}:${i}:*`, a = await this.client.keys(r);
+    a.length > 0 && await this.client.del(a);
+    const l = [];
+    for (let o = 0; o < e.length; o++) {
+      const [d, f] = e[o], y = `checkpoint_write:${n}:${s}:${c}:${i}:${o}`;
+      l.push(y);
+      const _ = {
+        thread_id: n,
+        checkpoint_ns: s,
+        checkpoint_id: c,
+        task_id: i,
+        idx: o,
+        channel: d,
+        type: typeof f == "object" ? "json" : "string",
+        value: f
+      };
+      await this.client.json.set(y, "$", _);
+    }
+    if (l.length > 0) {
+      const o = `write_keys_zset:${n}:${s}:${c}`, d = {};
+      l.forEach((f, y) => {
+        d[f] = y;
+      }), await this.client.zAdd(o, Object.entries(d).map(([f, y]) => ({
+        score: y,
+        value: f
+      }))), this.ttlConfig?.defaultTTL && await this.applyTTL(...l, o);
+    }
+    const h = `checkpoint:${n}:${s}:shallow`;
+    if (await this.client.exists(h)) {
+      const o = await this.client.json.get(h);
+      o && (o.has_writes = "true", await this.client.json.set(h, "$", o));
+    }
+  }
+  async deleteThread(t) {
+    const e = `checkpoint:${t}:*:shallow`, i = await this.client.keys(e);
+    i.length > 0 && await this.client.del(i);
+    const n = `checkpoint_write:${t}:*`, s = await this.client.keys(n);
+    s.length > 0 && await this.client.del(s);
+    const c = `write_keys_zset:${t}:*`, r = await this.client.keys(c);
+    r.length > 0 && await this.client.del(r);
+  }
+  async end() {
+    await this.client.quit();
+  }
+  addSearchableMetadataFields(t, e) {
+    e && ("source" in e && (t.source = e.source), "step" in e && (t.step = e.step), "writes" in e && (t.writes = typeof e.writes == "object" ? JSON.stringify(e.writes) : e.writes), "score" in e && (t.score = e.score));
+  }
+  async createCheckpointTuple(t, e, i) {
+    const n = await this.serde.loadsTyped("json", JSON.stringify(t.metadata));
+    return {
+      config: { configurable: {
+        thread_id: t.thread_id,
+        checkpoint_ns: t.checkpoint_ns,
+        checkpoint_id: t.checkpoint_id
+      } },
+      checkpoint: e,
+      metadata: n,
+      parentConfig: t.parent_checkpoint_id ? { configurable: {
+        thread_id: t.thread_id,
+        checkpoint_ns: t.checkpoint_ns,
+        checkpoint_id: t.parent_checkpoint_id
+      } } : void 0,
+      pendingWrites: i
+    };
+  }
+  async applyTTL(...t) {
+    if (!this.ttlConfig?.defaultTTL) return;
+    const e = Math.floor(this.ttlConfig.defaultTTL * 60), i = await Promise.allSettled(t.map((n) => this.client.expire(n, e)));
+    for (let n = 0; n < i.length; n++) i[n].status === "rejected" && console.warn(`Failed to set TTL for key ${t[n]}:`, i[n].reason);
+  }
+  async loadPendingWrites(t, e, i) {
+    const n = `write_keys_zset:${t}:${e}:${i}`, s = await this.client.zRange(n, 0, -1);
+    if (s.length === 0) return;
+    const c = [];
+    for (const r of s) {
+      const a = await this.client.json.get(r);
+      if (a) {
+        const l = await this.serde.loadsTyped("json", JSON.stringify(a.value));
+        c.push([
+          a.task_id,
+          a.channel,
+          l
+        ]);
+      }
+    }
+    return c;
+  }
+  checkMetadataFilterMatch(t, e) {
+    for (const [i, n] of Object.entries(e)) {
+      const s = t?.[i];
+      if (n === null) {
+        if (!(i in (t || {})) || s !== null) return !1;
+      } else if (typeof n == "object" && !Array.isArray(n)) {
+        if (typeof s != "object" || s === null || k(n) !== k(s)) return !1;
+      } else if (s !== n) return !1;
+    }
+    return !0;
+  }
+  async cleanupOldCheckpoint(t, e, i) {
+    const n = `checkpoint_write:${t}:${e}:${i}:*`, s = await this.client.keys(n);
+    s.length > 0 && await this.client.del(s);
+    const c = `write_keys_zset:${t}:${e}:${i}`;
+    await this.client.del(c);
+    const r = `checkpoint_blob:${t}:${e}:${i}:*`, a = await this.client.keys(r);
+    a.length > 0 && await this.client.del(a);
+  }
+  sanitizeMetadata(t) {
+    if (!t) return {};
+    const e = {};
+    for (const [i, n] of Object.entries(t)) {
+      const s = i.replace(/\x00/g, "");
+      e[s] = typeof n == "string" ? n.replace(/\x00/g, "") : n;
+    }
+    return e;
+  }
+  async ensureIndexes() {
+    for (const t of S) try {
+      await this.client.ft.create(t.index, t.schema, {
+        ON: "JSON",
+        PREFIX: t.prefix
+      });
+    } catch (e) {
+      e.message?.includes("Index already exists") || console.error(`Failed to create index ${t.index}:`, e.message);
+    }
+  }
+};
+export {
+  x as ShallowRedisSaver
+};