@wirecat/mail-cli 0.0.0-stage → 0.1.1

package/dist/bundle/node-GFOH6FKP.js

@@ -0,0 +1,176 @@
+import { createRequire as __bundleRequire } from "node:module";
+const require = __bundleRequire(import.meta.url);
+import {
+  DefaultLogger,
+  DrizzleQueryError,
+  NoopLogger,
+  SQLiteAsyncDatabase,
+  SQLiteAsyncPreparedQuery,
+  SQLiteAsyncSession,
+  SQLiteAsyncTransaction,
+  SQLiteDialect,
+  booleanFromInteger,
+  bufferFromBytes,
+  castToText,
+  dateFromStoredMilliseconds,
+  dateFromStoredSeconds,
+  entityKind,
+  jitCompatCheck,
+  refineSqliteCodecs,
+  sql
+} from "./chunk-EOEDICIE.js";
+import {
+  __name
+} from "./chunk-ZVVMGPBJ.js";
+
+// node_modules/.pnpm/@wirecat+cli-core@0.507.0_@wirecat+cli-base@0.68.1_commander@15.0.0_esbuild@0.28.2_type_d5beb0101c7a90701cc33879a5be8d28/node_modules/@wirecat/cli-core/dist/store/sqlite/drizzle/node.js
+import { DatabaseSync } from "node:sqlite";
+var nodeSQLiteCodecs = refineSqliteCodecs({
+  "integer:boolean": { normalize: booleanFromInteger },
+  "integer:timestamp": { normalize: dateFromStoredSeconds },
+  "integer:timestamp_ms": { normalize: dateFromStoredMilliseconds },
+  "text:json": { normalize: JSON.parse },
+  blob: { normalize: bufferFromBytes },
+  "blob:json": {
+    cast: castToText,
+    normalize: JSON.parse
+  },
+  "blob:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  },
+  numeric: {
+    cast: castToText,
+    normalize: String
+  },
+  "numeric:number": { normalize: Number },
+  "numeric:bigint": {
+    cast: castToText,
+    normalize: BigInt
+  }
+});
+var NodeSQLiteSession = class extends SQLiteAsyncSession {
+  static {
+    __name(this, "NodeSQLiteSession");
+  }
+  client;
+  relations;
+  options;
+  static [entityKind] = "SQLJsSession";
+  logger;
+  constructor(client, dialect, relations, options = {}) {
+    super(dialect, "sync");
+    this.client = client;
+    this.relations = relations;
+    this.options = options;
+    this.logger = options.logger ?? new NoopLogger();
+  }
+  prepareQuery(query, mode, _prepare, executeMethod, mapper, queryMetadata) {
+    let stmt;
+    try {
+      stmt = this.client.prepare(query.sql);
+    } catch (e) {
+      throw new DrizzleQueryError(query.sql, this.options.paramsInErrors ? query.params : void 0, e);
+    }
+    return new SQLiteAsyncPreparedQuery("sync", executeMethod, {
+      all: /* @__PURE__ */ __name((params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.all(...params);
+        if (mode === "objects") return res.map((row) => ({ ...row }));
+        return res;
+      }, "all"),
+      get: /* @__PURE__ */ __name((params) => {
+        stmt.setReturnArrays(mode === "arrays");
+        const res = stmt.get(...params);
+        if (res && mode === "objects") return { ...res };
+        return res;
+      }, "get"),
+      run: /* @__PURE__ */ __name((params) => {
+        stmt.setReturnArrays(false);
+        return stmt.run(...params);
+      }, "run")
+    }, query, mapper, mode, this.logger, void 0, queryMetadata, void 0, this.options.paramsInErrors);
+  }
+  transaction(transaction, config = {}) {
+    if (config?.behavior === "concurrent") throw new Error("Concurrent transactions are not supported by driver");
+    const tx = new NodeSQLiteTransaction("sync", this.dialect, this, this.relations);
+    this.run(sql.raw(`begin${config.behavior ? ` ${config.behavior}` : ""}`));
+    try {
+      const result = transaction(tx);
+      this.run(sql`commit`);
+      return result;
+    } catch (err) {
+      try {
+        this.run(sql`rollback`);
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+var NodeSQLiteTransaction = class NodeSQLiteTransaction2 extends SQLiteAsyncTransaction {
+  static {
+    __name(this, "NodeSQLiteTransaction2");
+  }
+  static [entityKind] = "SQLJsTransaction";
+  transaction(transaction) {
+    const savepointName = `sp${this.nestedIndex + 1}`;
+    const tx = new NodeSQLiteTransaction2("sync", this.dialect, this.session, this._.relations, this.nestedIndex + 1);
+    tx.run(sql.raw(`savepoint ${savepointName}`));
+    try {
+      const result = transaction(tx);
+      tx.run(sql.raw(`release savepoint ${savepointName}`));
+      return result;
+    } catch (err) {
+      try {
+        tx.run(sql.raw(`rollback to savepoint ${savepointName}`));
+      } catch {
+      }
+      throw err;
+    }
+  }
+};
+var NodeSQLiteDatabase = class extends SQLiteAsyncDatabase {
+  static {
+    __name(this, "NodeSQLiteDatabase");
+  }
+  static [entityKind] = "NodeSQLiteDatabase";
+};
+function construct(client, config = {}) {
+  const dialect = new SQLiteDialect({
+    codecs: config.codecs ?? nodeSQLiteCodecs,
+    useJitMappers: jitCompatCheck(config.jit)
+  });
+  let logger;
+  if (config.logger === true) logger = new DefaultLogger();
+  else if (config.logger !== false) logger = config.logger;
+  const relations = config.relations ?? {};
+  const db = new NodeSQLiteDatabase("sync", dialect, new NodeSQLiteSession(client, dialect, relations, {
+    logger,
+    paramsInErrors: config.paramsInErrors
+  }), relations);
+  db.$client = client;
+  return db;
+}
+__name(construct, "construct");
+function drizzle(...params) {
+  if (params[0] === void 0 || typeof params[0] === "string") return construct(params[0] === void 0 ? new DatabaseSync(":memory:") : new DatabaseSync(params[0]), params[1]);
+  const { connection, client, ...config } = params[0];
+  if (client) return construct(client, config);
+  if (typeof connection === "object") {
+    const { path, ...options } = connection;
+    return construct(new DatabaseSync(path ?? ":memory:", options), config);
+  }
+  return construct(new DatabaseSync(connection ?? ":memory:"), config);
+}
+__name(drizzle, "drizzle");
+(function(_drizzle) {
+  function mock(config) {
+    return construct({}, config);
+  }
+  __name(mock, "mock");
+  _drizzle.mock = mock;
+})(drizzle || (drizzle = {}));
+export {
+  drizzle
+};