@pablo2410/core-server 0.18.0 → 0.19.0

package/dist/db.d.ts

@@ -0,0 +1,97 @@
+import mysql, { Pool } from 'mysql2/promise';
+import * as drizzle_orm_mysql2 from 'drizzle-orm/mysql2';
+
+/**
+ * What keeps a database connection that TiDB has closed, or that has stalled,
+ * from failing or hanging this app (oplytics-subdomains#1285). On 21 Oct the
+ * test copy's Action Manager and SQDCP logged "Failed query" for creates and
+ * lists at random: every one was PROTOCOL_CONNECTION_LOST or ETIMEDOUT, a
+ * pooled connection the database had already closed. The pool had no
+ * keep-alive, no idle clean-up and no timeouts. The same fix has run in the
+ * Portal since portal#499. This is the one shared copy (core-server#137),
+ * without the Portal's request-level 503 flag.
+ *
+ * resilientPool() wraps a mysql2 promise pool so that:
+ *  - waiting for a free connection ends after ACQUIRE_TIMEOUT_MS;
+ *  - a query that gets no answer ends after READ_TIMEOUT_MS (reads) or
+ *    WRITE_TIMEOUT_MS (everything else), and its connection is DESTROYED, not
+ *    given back: mysql2's own `timeout` option leaves a dead connection in the
+ *    pool, where the next query would wait on it again;
+ *  - a read that fails on a dropped connection is tried once more on a fresh
+ *    one. Writes are never retried: the first one may have been applied.
+ *
+ * Every limit can be set with an environment variable (DB_ACQUIRE_TIMEOUT_MS,
+ * DB_QUERY_TIMEOUT_MS, DB_WRITE_TIMEOUT_MS). What the user is told when the
+ * database can't be reached is DB_UNAVAILABLE_MESSAGE (see withDbUnavailableMessage).
+ */
+
+interface Limits {
+    /** Longest wait for a free pooled connection. */
+    acquireTimeoutMs: number;
+    /** Longest wait for the answer to a read (SELECT, SHOW, ...). */
+    readTimeoutMs: number;
+    /** Longest wait for the answer to anything else. */
+    writeTimeoutMs: number;
+}
+declare const defaultLimits: () => Limits;
+/**
+ * Pool settings (merged into mysql2.createPool in dbClient.ts).
+ *  - connectTimeout: a new connection that does not come up fails in 10 s.
+ *  - enableKeepAlive: the OS notices a peer that has vanished.
+ *  - maxIdle < connectionLimit is what switches mysql2's idle clean-up on; it
+ *    then closes any connection idle for over idleTimeout, so connections are
+ *    replaced before TiDB closes them from its side.
+ *  - queueLimit: past this many requests waiting for a connection, new ones
+ *    fail at once instead of piling up behind stuck ones.
+ */
+declare const POOL_TUNING: {
+    readonly connectionLimit: 10;
+    readonly maxIdle: 5;
+    readonly idleTimeout: 60000;
+    readonly connectTimeout: 10000;
+    readonly enableKeepAlive: true;
+    readonly keepAliveInitialDelay: 10000;
+    readonly queueLimit: 200;
+};
+/** What a user sees when a request failed because the database was out of reach. */
+declare const DB_UNAVAILABLE_MESSAGE = "The database could not be reached just now. Please try again in a moment. If you were saving a change, check whether it was saved before you try again.";
+declare class DbUnavailableError extends Error {
+    code: "DB_ACQUIRE_TIMEOUT" | "DB_QUEUE_FULL" | "DB_QUERY_TIMEOUT";
+    constructor(code: "DB_ACQUIRE_TIMEOUT" | "DB_QUEUE_FULL" | "DB_QUERY_TIMEOUT", message: string);
+}
+declare const isDbUnavailable: (err: unknown) => boolean;
+/**
+ * For tRPC's errorFormatter: a call that failed because the database was out
+ * of reach tells the user so in plain words, never with the SQL that failed.
+ * Every other error keeps its message.
+ */
+declare function withDbUnavailableMessage<S extends {
+    message: string;
+}>(shape: S, error: unknown): S;
+declare function resilientPool<T extends Pool>(pool: T, overrides?: Partial<Limits>): T;
+
+/**
+ * Create a Drizzle client from a DATABASE_URL, enabling TLS when the host
+ * requires it. TiDB Cloud Serverless enforces TLS + SNI, so a bare `mysql://`
+ * URL is rejected ("Connections using insecure transport are prohibited") and
+ * the failure surfaces at query time as a generic "Failed query" error. For
+ * those hosts we connect with TLS; hosts that don't need TLS (e.g. plain local
+ * MySQL) use the connection string as it is.
+ *
+ * Set DATABASE_TLS=true to force TLS for a non-tidbcloud.com host.
+ */
+declare function connectionOptions(url: string): string | mysql.PoolOptions;
+/**
+ * Always a pool we configure ourselves (never drizzle's bare `drizzle(url)`
+ * one, which has no keep-alive or timeouts): connect, keep-alive, idle and
+ * queue limits from POOL_TUNING, and a wrapper that retries a read once on a
+ * fresh connection when TiDB has closed the old one, and ends a wait for a dead
+ * connection (resilience.ts, oplytics-subdomains#1285). `overrides`
+ * and `limits` are for tests.
+ */
+declare function createDbClient(url: string, overrides?: Partial<mysql.PoolOptions>, limits?: Partial<Limits>): drizzle_orm_mysql2.MySql2Database<Record<string, never>> & {
+    $client: mysql.Pool;
+};
+
+export { DB_UNAVAILABLE_MESSAGE, DbUnavailableError, POOL_TUNING, connectionOptions, createDbClient, defaultLimits, isDbUnavailable, resilientPool, withDbUnavailableMessage };
+export type { Limits };

package/dist/db.js

@@ -0,0 +1,208 @@
+// src/db/resilience.ts
+var envMs = (name, fallback) => {
+  const n = Number(process.env[name]);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+var defaultLimits = () => ({
+  acquireTimeoutMs: envMs("DB_ACQUIRE_TIMEOUT_MS", 1e4),
+  readTimeoutMs: envMs("DB_QUERY_TIMEOUT_MS", 15e3),
+  writeTimeoutMs: envMs("DB_WRITE_TIMEOUT_MS", 6e4)
+});
+var POOL_TUNING = {
+  connectionLimit: 10,
+  maxIdle: 5,
+  idleTimeout: 6e4,
+  connectTimeout: 1e4,
+  enableKeepAlive: true,
+  keepAliveInitialDelay: 1e4,
+  queueLimit: 200
+};
+var DB_UNAVAILABLE_MESSAGE = "The database could not be reached just now. Please try again in a moment. If you were saving a change, check whether it was saved before you try again.";
+var RETRY_CODES = /* @__PURE__ */ new Set([
+  "PROTOCOL_CONNECTION_LOST",
+  "PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR",
+  "PROTOCOL_ENQUEUE_AFTER_QUIT",
+  "ECONNRESET",
+  "EPIPE",
+  "ETIMEDOUT",
+  "ECONNREFUSED",
+  "EAI_AGAIN",
+  "DB_QUERY_TIMEOUT"
+]);
+var UNAVAILABLE_CODES = /* @__PURE__ */ new Set([
+  ...Array.from(RETRY_CODES),
+  "ENOTFOUND",
+  "DB_ACQUIRE_TIMEOUT",
+  "DB_QUEUE_FULL"
+]);
+var DbUnavailableError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "DbUnavailableError";
+  }
+  code;
+};
+function codes(err) {
+  const found = [];
+  let cur = err;
+  for (let depth = 0; cur && depth < 5; depth++) {
+    if (typeof cur.code === "string") found.push(cur.code);
+    cur = cur.cause;
+  }
+  return found;
+}
+var isDbUnavailable = (err) => codes(err).some((c) => UNAVAILABLE_CODES.has(c));
+function withDbUnavailableMessage(shape, error) {
+  return isDbUnavailable(error) ? { ...shape, message: DB_UNAVAILABLE_MESSAGE } : shape;
+}
+var isRetryable = (err) => codes(err).some((c) => RETRY_CODES.has(c));
+var READ_ONLY = /^\s*(select|show|describe|desc|explain)\b/i;
+var sqlOf = (first) => typeof first === "string" ? first : String(first?.sql ?? "");
+function dropIdleConnections(pool) {
+  try {
+    const free = pool.pool?._freeConnections;
+    if (!free || typeof free.get !== "function") return;
+    for (let guard = 0; free.length > 0 && guard < 100; guard++) {
+      free.get(0).destroy();
+    }
+  } catch {
+  }
+}
+function resilientPool(pool, overrides = {}) {
+  const limits = { ...defaultLimits(), ...overrides };
+  const acquire = async () => {
+    let timer;
+    let gaveUp = false;
+    const pending = pool.getConnection();
+    pending.then(
+      (conn) => {
+        if (gaveUp) conn.release();
+      },
+      () => void 0
+    );
+    const deadline = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        gaveUp = true;
+        reject(
+          new DbUnavailableError(
+            "DB_ACQUIRE_TIMEOUT",
+            `No database connection came free within ${limits.acquireTimeoutMs} ms`
+          )
+        );
+      }, limits.acquireTimeoutMs);
+    });
+    try {
+      return await Promise.race([pending, deadline]);
+    } catch (err) {
+      if (err instanceof Error && /queue limit reached/i.test(err.message)) {
+        throw new DbUnavailableError(
+          "DB_QUEUE_FULL",
+          "Too many requests are waiting for a database connection"
+        );
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const attempt = async (method, first, values, ms) => {
+    const conn = await acquire();
+    let timer;
+    let abandoned = false;
+    const deadline = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        abandoned = true;
+        conn.destroy();
+        dropIdleConnections(pool);
+        reject(
+          new DbUnavailableError(
+            "DB_QUERY_TIMEOUT",
+            `The database did not answer within ${ms} ms`
+          )
+        );
+      }, ms);
+    });
+    try {
+      const work = conn[method](first, values);
+      work.catch(() => void 0);
+      const out = await Promise.race([work, deadline]);
+      conn.release();
+      return out;
+    } catch (err) {
+      if (!abandoned) conn.release();
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  const run = async (method, first, values) => {
+    const read = READ_ONLY.test(sqlOf(first));
+    const ms = read ? limits.readTimeoutMs : limits.writeTimeoutMs;
+    try {
+      try {
+        return await attempt(method, first, values, ms);
+      } catch (err) {
+        if (!isRetryable(err)) throw err;
+        dropIdleConnections(pool);
+        if (!read) throw err;
+        console.warn(
+          `[Database] read failed (${codes(err)[0]}); trying once on a fresh connection`
+        );
+        return await attempt(method, first, values, ms);
+      }
+    } catch (err) {
+      if (isDbUnavailable(err)) {
+        console.error(
+          `[Database] unavailable (${codes(err)[0]}): ${err.message}`
+        );
+      }
+      throw err;
+    }
+  };
+  return new Proxy(pool, {
+    get(target, prop) {
+      if (prop === "query" || prop === "execute") {
+        return (first, values) => run(prop, first, values);
+      }
+      if (prop === "getConnection") return acquire;
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
+// src/db/client.ts
+import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+function connectionOptions(url) {
+  const requiresTls = /tidbcloud\.com/i.test(url) || process.env.DATABASE_TLS === "true";
+  if (!requiresTls) return url;
+  const parsed = new URL(url);
+  return {
+    host: parsed.hostname,
+    port: parsed.port ? Number(parsed.port) : 4e3,
+    user: decodeURIComponent(parsed.username),
+    password: decodeURIComponent(parsed.password),
+    database: parsed.pathname.replace(/^\//, ""),
+    ssl: { minVersion: "TLSv1.2" }
+  };
+}
+function createDbClient(url, overrides = {}, limits = {}) {
+  const options = connectionOptions(url);
+  const base = typeof options === "string" ? { uri: options } : options;
+  const pool = mysql.createPool({ ...base, ...POOL_TUNING, ...overrides });
+  return drizzle(resilientPool(pool, limits));
+}
+export {
+  DB_UNAVAILABLE_MESSAGE,
+  DbUnavailableError,
+  POOL_TUNING,
+  connectionOptions,
+  createDbClient,
+  defaultLimits,
+  isDbUnavailable,
+  resilientPool,
+  withDbUnavailableMessage
+};
+//# sourceMappingURL=db.js.map

package/dist/db.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/db/resilience.ts","../src/db/client.ts"],"sourcesContent":["/**\n * What keeps a database connection that TiDB has closed, or that has stalled,\n * from failing or hanging this app (oplytics-subdomains#1285). On 21 Oct the\n * test copy's Action Manager and SQDCP logged \"Failed query\" for creates and\n * lists at random: every one was PROTOCOL_CONNECTION_LOST or ETIMEDOUT, a\n * pooled connection the database had already closed. The pool had no\n * keep-alive, no idle clean-up and no timeouts. The same fix has run in the\n * Portal since portal#499. This is the one shared copy (core-server#137),\n * without the Portal's request-level 503 flag.\n *\n * resilientPool() wraps a mysql2 promise pool so that:\n *  - waiting for a free connection ends after ACQUIRE_TIMEOUT_MS;\n *  - a query that gets no answer ends after READ_TIMEOUT_MS (reads) or\n *    WRITE_TIMEOUT_MS (everything else), and its connection is DESTROYED, not\n *    given back: mysql2's own `timeout` option leaves a dead connection in the\n *    pool, where the next query would wait on it again;\n *  - a read that fails on a dropped connection is tried once more on a fresh\n *    one. Writes are never retried: the first one may have been applied.\n *\n * Every limit can be set with an environment variable (DB_ACQUIRE_TIMEOUT_MS,\n * DB_QUERY_TIMEOUT_MS, DB_WRITE_TIMEOUT_MS). What the user is told when the\n * database can't be reached is DB_UNAVAILABLE_MESSAGE (see withDbUnavailableMessage).\n */\nimport type { Pool, PoolConnection } from \"mysql2/promise\";\n\nconst envMs = (name: string, fallback: number) => {\n  const n = Number(process.env[name]);\n  return Number.isFinite(n) && n > 0 ? n : fallback;\n};\n\nexport interface Limits {\n  /** Longest wait for a free pooled connection. */\n  acquireTimeoutMs: number;\n  /** Longest wait for the answer to a read (SELECT, SHOW, ...). */\n  readTimeoutMs: number;\n  /** Longest wait for the answer to anything else. */\n  writeTimeoutMs: number;\n}\n\nexport const defaultLimits = (): Limits => ({\n  acquireTimeoutMs: envMs(\"DB_ACQUIRE_TIMEOUT_MS\", 10_000),\n  readTimeoutMs: envMs(\"DB_QUERY_TIMEOUT_MS\", 15_000),\n  writeTimeoutMs: envMs(\"DB_WRITE_TIMEOUT_MS\", 60_000),\n});\n\n/**\n * Pool settings (merged into mysql2.createPool in dbClient.ts).\n *  - connectTimeout: a new connection that does not come up fails in 10 s.\n *  - enableKeepAlive: the OS notices a peer that has vanished.\n *  - maxIdle < connectionLimit is what switches mysql2's idle clean-up on; it\n *    then closes any connection idle for over idleTimeout, so connections are\n *    replaced before TiDB closes them from its side.\n *  - queueLimit: past this many requests waiting for a connection, new ones\n *    fail at once instead of piling up behind stuck ones.\n */\nexport const POOL_TUNING = {\n  connectionLimit: 10,\n  maxIdle: 5,\n  idleTimeout: 60_000,\n  connectTimeout: 10_000,\n  enableKeepAlive: true,\n  keepAliveInitialDelay: 10_000,\n  queueLimit: 200,\n} as const;\n\n/** What a user sees when a request failed because the database was out of reach. */\nexport const DB_UNAVAILABLE_MESSAGE =\n  \"The database could not be reached just now. Please try again in a moment. If you were saving a change, check whether it was saved before you try again.\";\n\n// ─── telling a dropped database from a bad query ────────────────────────────\n\n/** Errors that mean \"that connection is gone\"; a read is worth one retry. */\nconst RETRY_CODES = new Set([\n  \"PROTOCOL_CONNECTION_LOST\",\n  \"PROTOCOL_ENQUEUE_AFTER_FATAL_ERROR\",\n  \"PROTOCOL_ENQUEUE_AFTER_QUIT\",\n  \"ECONNRESET\",\n  \"EPIPE\",\n  \"ETIMEDOUT\",\n  \"ECONNREFUSED\",\n  \"EAI_AGAIN\",\n  \"DB_QUERY_TIMEOUT\",\n]);\n/** Everything that means \"the database cannot be reached right now\". */\nconst UNAVAILABLE_CODES = new Set([\n  ...Array.from(RETRY_CODES),\n  \"ENOTFOUND\",\n  \"DB_ACQUIRE_TIMEOUT\",\n  \"DB_QUEUE_FULL\",\n]);\n\nexport class DbUnavailableError extends Error {\n  constructor(\n    public code: \"DB_ACQUIRE_TIMEOUT\" | \"DB_QUEUE_FULL\" | \"DB_QUERY_TIMEOUT\",\n    message: string\n  ) {\n    super(message);\n    this.name = \"DbUnavailableError\";\n  }\n}\n\n/** drizzle wraps a driver error and keeps the original as `cause`. */\nfunction codes(err: unknown): string[] {\n  const found: string[] = [];\n  let cur = err as { code?: unknown; cause?: unknown } | undefined;\n  for (let depth = 0; cur && depth < 5; depth++) {\n    if (typeof cur.code === \"string\") found.push(cur.code);\n    cur = cur.cause as typeof cur | undefined;\n  }\n  return found;\n}\n\nexport const isDbUnavailable = (err: unknown) =>\n  codes(err).some(c => UNAVAILABLE_CODES.has(c));\n\n/**\n * For tRPC's errorFormatter: a call that failed because the database was out\n * of reach tells the user so in plain words, never with the SQL that failed.\n * Every other error keeps its message.\n */\nexport function withDbUnavailableMessage<S extends { message: string }>(\n  shape: S,\n  error: unknown\n): S {\n  return isDbUnavailable(error)\n    ? { ...shape, message: DB_UNAVAILABLE_MESSAGE }\n    : shape;\n}\nconst isRetryable = (err: unknown) => codes(err).some(c => RETRY_CODES.has(c));\n\nconst READ_ONLY = /^\\s*(select|show|describe|desc|explain)\\b/i;\nconst sqlOf = (first: unknown): string =>\n  typeof first === \"string\"\n    ? first\n    : String((first as { sql?: unknown } | null)?.sql ?? \"\");\n\n// ─── the pool wrapper ───────────────────────────────────────────────────────\n\n/**\n * Close every connection that is sitting idle in the pool. When one connection\n * has stopped answering, the idle ones behind it have usually stopped too (the\n * network stalled, not one socket), and each would cost a request a timeout\n * before it was found out. mysql2 keeps them in a private queue and closes\n * idle ones the same way itself; if that shape ever changes this does nothing.\n */\nfunction dropIdleConnections(pool: Pool) {\n  try {\n    const free = (\n      pool as unknown as {\n        pool?: {\n          _freeConnections?: { length: number; get(i: number): PoolConnection };\n        };\n      }\n    ).pool?._freeConnections;\n    if (!free || typeof free.get !== \"function\") return;\n    for (let guard = 0; free.length > 0 && guard < 100; guard++) {\n      free.get(0).destroy();\n    }\n  } catch {\n    /* best effort */\n  }\n}\n\nexport function resilientPool<T extends Pool>(\n  pool: T,\n  overrides: Partial<Limits> = {}\n): T {\n  const limits = { ...defaultLimits(), ...overrides };\n\n  /** A free connection, or an error after acquireTimeoutMs. */\n  const acquire = async (): Promise<PoolConnection> => {\n    let timer: NodeJS.Timeout | undefined;\n    let gaveUp = false;\n    const pending = pool.getConnection();\n    // A connection that turns up after we gave up must go back, not leak.\n    pending.then(\n      conn => {\n        if (gaveUp) conn.release();\n      },\n      () => undefined\n    );\n    const deadline = new Promise<never>((_, reject) => {\n      timer = setTimeout(() => {\n        gaveUp = true;\n        reject(\n          new DbUnavailableError(\n            \"DB_ACQUIRE_TIMEOUT\",\n            `No database connection came free within ${limits.acquireTimeoutMs} ms`\n          )\n        );\n      }, limits.acquireTimeoutMs);\n    });\n    try {\n      return await Promise.race([pending, deadline]);\n    } catch (err) {\n      if (err instanceof Error && /queue limit reached/i.test(err.message)) {\n        throw new DbUnavailableError(\n          \"DB_QUEUE_FULL\",\n          \"Too many requests are waiting for a database connection\"\n        );\n      }\n      throw err;\n    } finally {\n      clearTimeout(timer);\n    }\n  };\n\n  /** One try on one connection. A connection that does not answer is destroyed. */\n  const attempt = async (\n    method: \"query\" | \"execute\",\n    first: unknown,\n    values: unknown,\n    ms: number\n  ) => {\n    const conn = await acquire();\n    let timer: NodeJS.Timeout | undefined;\n    let abandoned = false;\n    const deadline = new Promise<never>((_, reject) => {\n      timer = setTimeout(() => {\n        abandoned = true;\n        conn.destroy();\n        dropIdleConnections(pool);\n        reject(\n          new DbUnavailableError(\n            \"DB_QUERY_TIMEOUT\",\n            `The database did not answer within ${ms} ms`\n          )\n        );\n      }, ms);\n    });\n    try {\n      const work = (\n        conn[method] as (a: unknown, b?: unknown) => Promise<unknown>\n      )(first, values);\n      // The destroyed connection fails this later; nobody is waiting for it.\n      work.catch(() => undefined);\n      const out = await Promise.race([work, deadline]);\n      conn.release();\n      return out;\n    } catch (err) {\n      if (!abandoned) conn.release();\n      throw err;\n    } finally {\n      clearTimeout(timer);\n    }\n  };\n\n  const run = async (\n    method: \"query\" | \"execute\",\n    first: unknown,\n    values?: unknown\n  ) => {\n    const read = READ_ONLY.test(sqlOf(first));\n    const ms = read ? limits.readTimeoutMs : limits.writeTimeoutMs;\n    try {\n      try {\n        return await attempt(method, first, values, ms);\n      } catch (err) {\n        if (!isRetryable(err)) throw err;\n        // A blip that drops one connection drops the ones idle beside it too,\n        // and the pool hands out the next idle one unchecked: close them, so\n        // the retry (or, for a write, the user's own retry) gets a fresh one.\n        dropIdleConnections(pool);\n        if (!read) throw err;\n        console.warn(\n          `[Database] read failed (${codes(err)[0]}); trying once on a fresh connection`\n        );\n        return await attempt(method, first, values, ms);\n      }\n    } catch (err) {\n      if (isDbUnavailable(err)) {\n        console.error(\n          `[Database] unavailable (${codes(err)[0]}): ${(err as Error).message}`\n        );\n      }\n      throw err;\n    }\n  };\n\n  return new Proxy(pool, {\n    get(target, prop) {\n      if (prop === \"query\" || prop === \"execute\") {\n        return (first: unknown, values?: unknown) => run(prop, first, values);\n      }\n      if (prop === \"getConnection\") return acquire;\n      const value = Reflect.get(target, prop, target);\n      return typeof value === \"function\" ? value.bind(target) : value;\n    },\n  });\n}\n","/* Shared Drizzle client factory. */\nimport { drizzle } from \"drizzle-orm/mysql2\";\nimport mysql from \"mysql2/promise\";\nimport { POOL_TUNING, resilientPool, type Limits } from \"./resilience\";\n\n/**\n * Create a Drizzle client from a DATABASE_URL, enabling TLS when the host\n * requires it. TiDB Cloud Serverless enforces TLS + SNI, so a bare `mysql://`\n * URL is rejected (\"Connections using insecure transport are prohibited\") and\n * the failure surfaces at query time as a generic \"Failed query\" error. For\n * those hosts we connect with TLS; hosts that don't need TLS (e.g. plain local\n * MySQL) use the connection string as it is.\n *\n * Set DATABASE_TLS=true to force TLS for a non-tidbcloud.com host.\n */\nexport function connectionOptions(url: string): string | mysql.PoolOptions {\n  const requiresTls =\n    /tidbcloud\\.com/i.test(url) || process.env.DATABASE_TLS === \"true\";\n  if (!requiresTls) return url;\n  const parsed = new URL(url);\n  return {\n    host: parsed.hostname,\n    port: parsed.port ? Number(parsed.port) : 4000,\n    user: decodeURIComponent(parsed.username),\n    password: decodeURIComponent(parsed.password),\n    database: parsed.pathname.replace(/^\\//, \"\"),\n    ssl: { minVersion: \"TLSv1.2\" },\n  };\n}\n\n/**\n * Always a pool we configure ourselves (never drizzle's bare `drizzle(url)`\n * one, which has no keep-alive or timeouts): connect, keep-alive, idle and\n * queue limits from POOL_TUNING, and a wrapper that retries a read once on a\n * fresh connection when TiDB has closed the old one, and ends a wait for a dead\n * connection (resilience.ts, oplytics-subdomains#1285). `overrides`\n * and `limits` are for tests.\n */\nexport function createDbClient(\n  url: string,\n  overrides: Partial<mysql.PoolOptions> = {},\n  limits: Partial<Limits> = {}\n) {\n  const options = connectionOptions(url);\n  const base = typeof options === \"string\" ? { uri: options } : options;\n  const pool = mysql.createPool({ ...base, ...POOL_TUNING, ...overrides });\n  return drizzle(resilientPool(pool, limits));\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pablo2410/core-server",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Shared server utilities for Oplytics.digital subdomains",
   "type": "module",
   "exports": {
@@ -19,6 +19,10 @@
     "./isolation": {
       "types": "./dist/isolation.d.ts",
       "import": "./dist/isolation.js"
+    },
+    "./db": {
+      "types": "./dist/db.d.ts",
+      "import": "./dist/db.js"
     }
   },
   "files": [
@@ -46,10 +50,12 @@
     "@types/node": "^26.6.6",
     "axios": "^1.21.0",
     "cookie": "^2.0.1",
-    "eslint": "^10.13.0",
+    "drizzle-orm": "^0.45.4",
+    "eslint": "^10.14.0",
     "express": "^5.3.0",
     "globals": "^17.13.0",
     "jose": "^6.2.14",
+    "mysql2": "^3.24.6",
     "prettier": "^3.9.10",
     "tsup": "^9.0.0",
     "typescript": "^5.6.0",
@@ -62,7 +68,9 @@
     "axios": ">=1.0.0",
     "cookie": ">=0.6.0",
     "express": ">=4.0.0",
-    "jose": ">=5.0.0"
+    "jose": ">=5.0.0",
+    "drizzle-orm": ">=0.30.0",
+    "mysql2": ">=3.0.0"
   },
   "peerDependenciesMeta": {
     "@pablo2410/shared-ui": {
@@ -79,6 +87,12 @@
     },
     "axios": {
       "optional": true
+    },
+    "drizzle-orm": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
     }
   },
   "pnpm": {