@book000/pixivts-db-mysql 0.60.0 → 0.60.2

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/schema.ts","../src/connection.ts","../src/recorder.ts","../src/migrations.ts"],"mappings":";;;;;;;;;;;;;;;;;;;AAwBA;;cAAa,cAAA,mCAAc,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAoC1B,IAAA;;;;;;;;;;;;;;;;KAGW,WAAA,UAAqB,cAAA,CAAe,YAAY;;KAGhD,WAAA,UAAqB,cAAA,CAAe,YAAY;;;;UCvD3C,iBAAA;;ADajB;;;ECRE,IAAA;EDQyB;;;;ECFzB,IAAA;;;;;EAMA,IAAA;;;;;EAMA,QAAA;;;;;EAMA,QAAA;AAAA;;;;;;KAQU,UAAA,GAAa,UAAA,QAAkB,OAAA,QAAe,gBAAA;;;;;;;;iBAe1C,kBAAA,CAAmB,IAAA,EAAM,iBAAA;EACvC,IAAA,EAAM,KAAA,CAAM,IAAA;EACZ,EAAA,EAAI,UAAA;AAAA;;;;UCzCW,cAAA;;;;;EAKf,WAAA,EAAa,mBAAA;;EAGb,EAAA,EAAI,UAAA;;EAGJ,KAAA,IAAS,OAAA;AAAA;;UAQM,eAAA,SAAwB,iBAAiB;;;;;;;EAOxD,SAAS;AAAA;;;;;;;;;;iBA8CW,WAAA,CACpB,EAAA,EAAI,UAAA,EACJ,MAAA,EAAQ,cAAA,GACP,OAAA;;;;;;;;;iBAkCa,oBAAA,CACd,EAAA,EAAI,UAAA,EACJ,KAAA,QAAa,OAAA,SACZ,cAAA;;;;;;;;;;;;;;;;;;;iBAyBmB,sBAAA,CACpB,IAAA,EAAM,eAAA,GACL,OAAA,CAAQ,cAAA;;UAeM,cAAA;;EAEf,MAAA;;EAEA,QAAA;;EAEA,UAAA;AAAA;;UAIe,YAAA;;EAEf,IAAA;;EAEA,KAAK;AAAA;;;;;;;;;iBAWe,YAAA,CACpB,EAAA,EAAI,UAAA,EACJ,MAAA,GAAS,cAAA,EACT,KAAA,GAAQ,YAAA,GACP,OAAA,CAAQ,WAAA;;;;;;;;iBAkCW,gBAAA,CACpB,EAAA,EAAI,UAAA,EACJ,MAAA,GAAS,cAAA,GACR,OAAA;;UAuBc,iBAAA;;EAEf,MAAA;;EAEA,QAAA;;EAEA,UAAA;;EAEA,KAAA;AAAA;;;;;;;;iBAUoB,YAAA,CAAa,EAAA,EAAI,UAAA,GAAa,OAAA,CAAQ,iBAAA;;;AFrQ5D;;;;;;;;AAAA,iBGFsB,eAAA,CAAgB,EAAA,EAAI,UAAA,GAAa,OAAO"}

package/dist/index.js

@@ -1,80 +1,113 @@
-import { drizzle } from 'drizzle-orm/mysql2';
-import mysql from 'mysql2/promise';
-import { mysqlTable, datetime, longtext, int, varchar, text, uniqueIndex } from 'drizzle-orm/mysql-core';
-import crypto from 'crypto';
-import { sql, and, gte, eq, desc, count } from 'drizzle-orm';
-
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  responsesTable: () => responsesTable
-});
-var responsesTable = mysqlTable(
-  "responses",
-  {
-    /** Auto-increment primary key. */
-    id: int("id").autoincrement().primaryKey(),
-    /** HTTP method (GET or POST). */
-    method: varchar("method", { length: 10 }).notNull(),
-    /** API endpoint path (e.g. /v1/illust/detail). */
-    endpoint: varchar("endpoint", { length: 255 }).notNull(),
-    /** Full request URL (may be null for internal requests). */
-    url: text("url"),
-    /** SHA-256 hash of the request URL for deduplication. */
-    urlHash: varchar("url_hash", { length: 255 }).notNull(),
-    /** Serialised request headers (JSON string). */
-    requestHeaders: longtext("request_headers"),
-    /** Request body (URL-encoded string for POST, null for GET). */
-    requestBody: longtext("request_body"),
-    /** Response content type ("JSON" or "TEXT"). */
-    responseType: varchar("response_type", { length: 10 }).notNull(),
-    /** HTTP response status code. */
-    statusCode: int("status_code").notNull(),
-    /** Serialised response headers (JSON string). */
-    responseHeaders: longtext("response_headers"),
-    /** Raw response body. */
-    responseBody: longtext("response_body").notNull(),
-    /** Timestamp when the record was created. */
-    createdAt: datetime("created_at", { mode: "date", fsp: 3 }).notNull()
-  },
-  (table) => [
-    uniqueIndex("idx_unique").on(
-      table.method,
-      table.endpoint,
-      table.statusCode,
-      table.urlHash
-    )
-  ]
-);
-
-// src/connection.ts
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+import { datetime, int, longtext, mysqlTable, text, uniqueIndex, varchar } from "drizzle-orm/mysql-core";
+import crypto from "node:crypto";
+import { and, count, desc, eq, gte, sql } from "drizzle-orm";
+//#region src/schema.ts
+/**
+* Drizzle ORM schema for the `responses` table.
+*
+* Column names are kept in snake_case to match the legacy TypeORM schema
+* so that existing databases can be used without migration.
+*/
+var schema_exports = /* @__PURE__ */ __exportAll({ responsesTable: () => responsesTable });
+/**
+* The `responses` table stores every HTTP response returned by the pixiv API.
+*
+* A unique composite index on (method, endpoint, status_code, url_hash) ensures
+* that each unique request/response combination is stored only once, regardless
+* of when it was recorded.
+*/
+const responsesTable = mysqlTable("responses", {
+	/** Auto-increment primary key. */
+	id: int("id").autoincrement().primaryKey(),
+	/** HTTP method (GET or POST). */
+	method: varchar("method", { length: 10 }).notNull(),
+	/** API endpoint path (e.g. /v1/illust/detail). */
+	endpoint: varchar("endpoint", { length: 255 }).notNull(),
+	/** Full request URL (may be null for internal requests). */
+	url: text("url"),
+	/** SHA-256 hash of the request URL for deduplication. */
+	urlHash: varchar("url_hash", { length: 255 }).notNull(),
+	/** Serialised request headers (JSON string). */
+	requestHeaders: longtext("request_headers"),
+	/** Request body (URL-encoded string for POST, null for GET). */
+	requestBody: longtext("request_body"),
+	/** Response content type ("JSON" or "TEXT"). */
+	responseType: varchar("response_type", { length: 10 }).notNull(),
+	/** HTTP response status code. */
+	statusCode: int("status_code").notNull(),
+	/** Serialised response headers (JSON string). */
+	responseHeaders: longtext("response_headers"),
+	/** Raw response body. */
+	responseBody: longtext("response_body").notNull(),
+	/** Timestamp when the record was created. */
+	createdAt: datetime("created_at", {
+		mode: "date",
+		fsp: 3
+	}).notNull()
+}, (table) => [uniqueIndex("idx_unique").on(table.method, table.endpoint, table.statusCode, table.urlHash)]);
+//#endregion
+//#region src/connection.ts
+/**
+* MySQL connection factory for @book000/pixivts-db-mysql.
+*
+* Creates a mysql2 connection pool and wraps it in a Drizzle ORM instance.
+*/
 function parsePort(value) {
-  if (!value) return 3306;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isNaN(parsed) ? 3306 : parsed;
+	if (!value) return 3306;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isNaN(parsed) ? 3306 : parsed;
 }
+/**
+* Creates a mysql2 connection pool and returns both the raw pool and the
+* Drizzle ORM wrapper.
+*
+* @param opts - Connection options (fall back to environment variables)
+* @returns `{ pool, db }` — raw pool for `close()`, db for queries
+*/
 function createDbConnection(opts) {
-  const pool = mysql.createPool({
-    host: opts.host ?? process.env.RESPONSE_DB_HOSTNAME ?? "localhost",
-    port: opts.port ?? parsePort(process.env.RESPONSE_DB_PORT),
-    user: opts.user ?? process.env.RESPONSE_DB_USERNAME,
-    password: opts.password ?? process.env.RESPONSE_DB_PASSWORD,
-    database: opts.database ?? process.env.RESPONSE_DB_DATABASE,
-    timezone: "+09:00",
-    supportBigNumbers: true,
-    bigNumberStrings: true
-  });
-  const db = drizzle(pool, { schema: schema_exports, mode: "default" });
-  return { pool, db };
+	const pool = mysql.createPool({
+		host: opts.host ?? process.env.RESPONSE_DB_HOSTNAME ?? "localhost",
+		port: opts.port ?? parsePort(process.env.RESPONSE_DB_PORT),
+		user: opts.user ?? process.env.RESPONSE_DB_USERNAME,
+		password: opts.password ?? process.env.RESPONSE_DB_PASSWORD,
+		database: opts.database ?? process.env.RESPONSE_DB_DATABASE,
+		timezone: "+09:00",
+		supportBigNumbers: true,
+		bigNumberStrings: true
+	});
+	return {
+		pool,
+		db: drizzle(pool, {
+			schema: schema_exports,
+			mode: "default"
+		})
+	};
 }
+//#endregion
+//#region src/migrations.ts
+/**
+* Schema bootstrapping for @book000/pixivts-db-mysql.
+*
+* Provides a `CREATE TABLE IF NOT EXISTS` helper that can be used at startup
+* without requiring drizzle-kit to be installed in production.
+*
+* For full migrations, use:
+*   pnpm drizzle-kit generate
+*   pnpm drizzle-kit migrate
+*/
+/**
+* Creates the `responses` table if it does not already exist.
+*
+* This is a lightweight alternative to running drizzle-kit migrations in
+* environments where the table has not been set up yet.
+*
+* @param db - Drizzle ORM database instance
+*/
 async function bootstrapSchema(db) {
-  await db.execute(sql`
+	await db.execute(sql`
     CREATE TABLE IF NOT EXISTS responses (
       id           INT AUTO_INCREMENT PRIMARY KEY COMMENT 'Response ID',
       method       VARCHAR(10)   NOT NULL COMMENT 'HTTP method',
@@ -92,77 +125,150 @@ async function bootstrapSchema(db) {
     ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
   `);
 }
-
-// src/recorder.ts
+//#endregion
+//#region src/recorder.ts
+/**
+* Response recorder for @book000/pixivts-db-mysql.
+*
+* `createResponseRecorder()` returns a `{ interceptor, db, close }` bundle:
+*   - `interceptor` — pass to `PixivClient.of(token, { onResponse: interceptor })`
+*   - `db` — the raw Drizzle instance for custom queries
+*   - `close()` — shuts down the connection pool
+*
+* The recorder uses Drizzle ORM's `onDuplicateKeyUpdate` to silently ignore
+* duplicate entries (same method + endpoint + statusCode + urlHash).
+*/
+/**
+* Creates a response recorder that persists every pixiv API response to MySQL.
+*
+* @param opts - Connection and bootstrapping options
+* @returns `{ interceptor, db, close }`
+*
+* @example
+* ```ts
+* const { interceptor, close } = await createResponseRecorder({
+*   host: 'localhost',
+*   database: 'pixivts',
+*   bootstrap: true,
+* })
+* const client = await PixivClient.of(token, { onResponse: interceptor })
+* // ...
+* await close()
+* ```
+*/
 function ninetyDaysAgo() {
-  return new Date(Date.now() - 90 * 24 * 60 * 60 * 1e3);
+	return /* @__PURE__ */ new Date(Date.now() - 2160 * 60 * 60 * 1e3);
 }
+/**
+* Inserts a response record into the database.
+*
+* If the unique composite index fires (duplicate method + endpoint + statusCode
+* + urlHash), the insert is silently ignored via `ON DUPLICATE KEY UPDATE id = id`.
+*
+* @param db - Drizzle ORM database instance
+* @param record - Response record from the HTTP client interceptor
+*/
 async function addResponse(db, record) {
-  const urlToHash = record.url ?? `${record.method}:${record.endpoint}`;
-  const urlHash = crypto.createHash("sha256").update(urlToHash).digest("hex");
-  await db.insert(responsesTable).values({
-    method: record.method,
-    endpoint: record.endpoint,
-    url: record.url,
-    urlHash,
-    requestHeaders: record.requestHeaders,
-    requestBody: record.requestBody,
-    responseType: record.responseType,
-    statusCode: record.statusCode,
-    responseHeaders: record.responseHeaders,
-    responseBody: record.responseBody,
-    createdAt: /* @__PURE__ */ new Date()
-  }).onDuplicateKeyUpdate({ set: { id: sql`id` } });
+	const urlToHash = record.url ?? `${record.method}:${record.endpoint}`;
+	const urlHash = crypto.createHash("sha256").update(urlToHash).digest("hex");
+	await db.insert(responsesTable).values({
+		method: record.method,
+		endpoint: record.endpoint,
+		url: record.url,
+		urlHash,
+		requestHeaders: record.requestHeaders,
+		requestBody: record.requestBody,
+		responseType: record.responseType,
+		statusCode: record.statusCode,
+		responseHeaders: record.responseHeaders,
+		responseBody: record.responseBody,
+		createdAt: /* @__PURE__ */ new Date()
+	}).onDuplicateKeyUpdate({ set: { id: sql`id` } });
 }
+/**
+* Creates a `RecorderBundle` from an existing Drizzle instance.
+*
+* Useful for testing — pass a mock `db` and a no-op `close`.
+*
+* @param db - Drizzle ORM database instance
+* @param close - Function that closes the underlying connection
+*/
 function createRecorderBundle(db, close) {
-  const interceptor = (record) => addResponse(db, record);
-  return { interceptor, db, close };
+	const interceptor = (record) => addResponse(db, record);
+	return {
+		interceptor,
+		db,
+		close
+	};
 }
+/**
+* Creates a response recorder that persists every pixiv API response to MySQL.
+*
+* @param opts - Connection and bootstrapping options
+* @returns `{ interceptor, db, close }`
+*
+* @example
+* ```ts
+* const { interceptor, close } = await createResponseRecorder({
+*   host: 'localhost',
+*   database: 'pixivts',
+*   bootstrap: true,
+* })
+* const client = await PixivClient.of(token, { onResponse: interceptor })
+* // ...
+* await close()
+* ```
+*/
 async function createResponseRecorder(opts) {
-  const { pool, db } = createDbConnection(opts);
-  if (opts.bootstrap) {
-    await bootstrapSchema(db);
-  }
-  return createRecorderBundle(db, () => pool.end());
+	const { pool, db } = createDbConnection(opts);
+	if (opts.bootstrap) await bootstrapSchema(db);
+	return createRecorderBundle(db, () => pool.end());
 }
+/**
+* Retrieves response records from the last 90 days.
+*
+* @param db - Drizzle ORM database instance
+* @param filter - Optional filter criteria
+* @param range - Optional pagination options
+* @returns Array of response rows, newest first
+*/
 async function getResponses(db, filter, range) {
-  const since = ninetyDaysAgo();
-  const limit = range?.limit ?? 100;
-  const offset = ((range?.page ?? 1) - 1) * limit;
-  return db.select().from(responsesTable).where(
-    and(
-      gte(responsesTable.createdAt, since),
-      filter?.method ? eq(responsesTable.method, filter.method) : void 0,
-      filter?.endpoint ? eq(responsesTable.endpoint, filter.endpoint) : void 0,
-      filter?.statusCode ? eq(responsesTable.statusCode, filter.statusCode) : void 0
-    )
-  ).orderBy(desc(responsesTable.createdAt)).limit(limit).offset(offset);
+	const since = ninetyDaysAgo();
+	const limit = range?.limit ?? 100;
+	const offset = ((range?.page ?? 1) - 1) * limit;
+	return db.select().from(responsesTable).where(and(gte(responsesTable.createdAt, since), filter?.method ? eq(responsesTable.method, filter.method) : void 0, filter?.endpoint ? eq(responsesTable.endpoint, filter.endpoint) : void 0, filter?.statusCode ? eq(responsesTable.statusCode, filter.statusCode) : void 0)).orderBy(desc(responsesTable.createdAt)).limit(limit).offset(offset);
 }
+/**
+* Returns the total count of response records from the last 90 days.
+*
+* @param db - Drizzle ORM database instance
+* @param filter - Optional filter criteria
+* @returns Total row count matching the filter
+*/
 async function getResponseCount(db, filter) {
-  const since = ninetyDaysAgo();
-  const rows = await db.select({ value: count() }).from(responsesTable).where(
-    and(
-      gte(responsesTable.createdAt, since),
-      filter?.method ? eq(responsesTable.method, filter.method) : void 0,
-      filter?.endpoint ? eq(responsesTable.endpoint, filter.endpoint) : void 0,
-      filter?.statusCode ? eq(responsesTable.statusCode, filter.statusCode) : void 0
-    )
-  );
-  return rows[0]?.value ?? 0;
+	const since = ninetyDaysAgo();
+	return (await db.select({ value: count() }).from(responsesTable).where(and(gte(responsesTable.createdAt, since), filter?.method ? eq(responsesTable.method, filter.method) : void 0, filter?.endpoint ? eq(responsesTable.endpoint, filter.endpoint) : void 0, filter?.statusCode ? eq(responsesTable.statusCode, filter.statusCode) : void 0)))[0]?.value ?? 0;
 }
+/**
+* Returns all unique (method, endpoint, statusCode) combinations seen in the
+* last 90 days, along with the count of matching records.
+*
+* @param db - Drizzle ORM database instance
+* @returns Endpoints sorted by count descending
+*/
 async function getEndpoints(db) {
-  const since = ninetyDaysAgo();
-  const rows = await db.select({
-    method: responsesTable.method,
-    endpoint: responsesTable.endpoint,
-    statusCode: responsesTable.statusCode,
-    count: count()
-  }).from(responsesTable).where(gte(responsesTable.createdAt, since)).groupBy(
-    responsesTable.method,
-    responsesTable.endpoint,
-    responsesTable.statusCode
-  ).orderBy(desc(count()));
-  return rows.map((r) => ({ ...r, count: r.count }));
+	const since = ninetyDaysAgo();
+	return (await db.select({
+		method: responsesTable.method,
+		endpoint: responsesTable.endpoint,
+		statusCode: responsesTable.statusCode,
+		count: count()
+	}).from(responsesTable).where(gte(responsesTable.createdAt, since)).groupBy(responsesTable.method, responsesTable.endpoint, responsesTable.statusCode).orderBy(desc(count()))).map((r) => ({
+		...r,
+		count: r.count
+	}));
 }
-
+//#endregion
 export { addResponse, bootstrapSchema, createDbConnection, createRecorderBundle, createResponseRecorder, getEndpoints, getResponseCount, getResponses, responsesTable };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/schema.ts","../src/connection.ts","../src/migrations.ts","../src/recorder.ts"],"sourcesContent":["/**\n * Drizzle ORM schema for the `responses` table.\n *\n * Column names are kept in snake_case to match the legacy TypeORM schema\n * so that existing databases can be used without migration.\n */\n\nimport {\n  int,\n  datetime,\n  longtext,\n  mysqlTable,\n  text,\n  varchar,\n  uniqueIndex,\n} from 'drizzle-orm/mysql-core'\n\n/**\n * The `responses` table stores every HTTP response returned by the pixiv API.\n *\n * A unique composite index on (method, endpoint, status_code, url_hash) ensures\n * that each unique request/response combination is stored only once, regardless\n * of when it was recorded.\n */\nexport const responsesTable = mysqlTable(\n  'responses',\n  {\n    /** Auto-increment primary key. */\n    id: int('id').autoincrement().primaryKey(),\n    /** HTTP method (GET or POST). */\n    method: varchar('method', { length: 10 }).notNull(),\n    /** API endpoint path (e.g. /v1/illust/detail). */\n    endpoint: varchar('endpoint', { length: 255 }).notNull(),\n    /** Full request URL (may be null for internal requests). */\n    url: text('url'),\n    /** SHA-256 hash of the request URL for deduplication. */\n    urlHash: varchar('url_hash', { length: 255 }).notNull(),\n    /** Serialised request headers (JSON string). */\n    requestHeaders: longtext('request_headers'),\n    /** Request body (URL-encoded string for POST, null for GET). */\n    requestBody: longtext('request_body'),\n    /** Response content type (\"JSON\" or \"TEXT\"). */\n    responseType: varchar('response_type', { length: 10 }).notNull(),\n    /** HTTP response status code. */\n    statusCode: int('status_code').notNull(),\n    /** Serialised response headers (JSON string). */\n    responseHeaders: longtext('response_headers'),\n    /** Raw response body. */\n    responseBody: longtext('response_body').notNull(),\n    /** Timestamp when the record was created. */\n    createdAt: datetime('created_at', { mode: 'date', fsp: 3 }).notNull(),\n  },\n  (table) => [\n    uniqueIndex('idx_unique').on(\n      table.method,\n      table.endpoint,\n      table.statusCode,\n      table.urlHash\n    ),\n  ]\n)\n\n/** Type for inserting a new response record. */\nexport type NewResponse = typeof responsesTable.$inferInsert\n\n/** Type for a selected response record. */\nexport type ResponseRow = typeof responsesTable.$inferSelect\n","/**\n * MySQL connection factory for @book000/pixivts-db-mysql.\n *\n * Creates a mysql2 connection pool and wraps it in a Drizzle ORM instance.\n */\n\nimport { drizzle } from 'drizzle-orm/mysql2'\nimport mysql from 'mysql2/promise'\nimport * as schema from './schema'\n\n/** Options for establishing a MySQL connection. */\nexport interface ConnectionOptions {\n  /**\n   * Database hostname.\n   * Falls back to the `RESPONSE_DB_HOSTNAME` environment variable.\n   */\n  host?: string\n\n  /**\n   * Database port.\n   * Falls back to the `RESPONSE_DB_PORT` environment variable (default: 3306).\n   */\n  port?: number\n\n  /**\n   * Database username.\n   * Falls back to the `RESPONSE_DB_USERNAME` environment variable.\n   */\n  user?: string\n\n  /**\n   * Database password.\n   * Falls back to the `RESPONSE_DB_PASSWORD` environment variable.\n   */\n  password?: string\n\n  /**\n   * Database name.\n   * Falls back to the `RESPONSE_DB_DATABASE` environment variable.\n   */\n  database?: string\n}\n\n/**\n * The Drizzle ORM database instance type returned by `createConnection`.\n *\n * Typed with the `schema` so that relational queries are available.\n */\nexport type DbInstance = ReturnType<typeof drizzle<typeof schema>>\n\nfunction parsePort(value: string | undefined): number {\n  if (!value) return 3306\n  const parsed = Number.parseInt(value, 10)\n  return Number.isNaN(parsed) ? 3306 : parsed\n}\n\n/**\n * Creates a mysql2 connection pool and returns both the raw pool and the\n * Drizzle ORM wrapper.\n *\n * @param opts - Connection options (fall back to environment variables)\n * @returns `{ pool, db }` — raw pool for `close()`, db for queries\n */\nexport function createDbConnection(opts: ConnectionOptions): {\n  pool: mysql.Pool\n  db: DbInstance\n} {\n  const pool = mysql.createPool({\n    host: opts.host ?? process.env.RESPONSE_DB_HOSTNAME ?? 'localhost',\n    port: opts.port ?? parsePort(process.env.RESPONSE_DB_PORT),\n    user: opts.user ?? process.env.RESPONSE_DB_USERNAME,\n    password: opts.password ?? process.env.RESPONSE_DB_PASSWORD,\n    database: opts.database ?? process.env.RESPONSE_DB_DATABASE,\n    timezone: '+09:00',\n    supportBigNumbers: true,\n    bigNumberStrings: true,\n  })\n\n  // Type assertion required: pnpm's peer-dep resolution for the patched drizzle-orm\n  // creates a structurally-incompatible Pool type for the $client property.\n  // The runtime value is correct; only the declaration paths differ.\n  const db = drizzle(pool, { schema, mode: 'default' }) as unknown as DbInstance\n  return { pool, db }\n}\n","/**\n * Schema bootstrapping for @book000/pixivts-db-mysql.\n *\n * Provides a `CREATE TABLE IF NOT EXISTS` helper that can be used at startup\n * without requiring drizzle-kit to be installed in production.\n *\n * For full migrations, use:\n *   pnpm drizzle-kit generate\n *   pnpm drizzle-kit migrate\n */\n\nimport { sql } from 'drizzle-orm'\nimport type { DbInstance } from './connection'\n\n/**\n * Creates the `responses` table if it does not already exist.\n *\n * This is a lightweight alternative to running drizzle-kit migrations in\n * environments where the table has not been set up yet.\n *\n * @param db - Drizzle ORM database instance\n */\nexport async function bootstrapSchema(db: DbInstance): Promise<void> {\n  await db.execute(sql`\n    CREATE TABLE IF NOT EXISTS responses (\n      id           INT AUTO_INCREMENT PRIMARY KEY COMMENT 'Response ID',\n      method       VARCHAR(10)   NOT NULL COMMENT 'HTTP method',\n      endpoint     VARCHAR(255)  NOT NULL COMMENT 'API endpoint path',\n      url          TEXT          NULL     COMMENT 'Full request URL',\n      url_hash     VARCHAR(255)  NOT NULL COMMENT 'SHA-256 hash of the request URL',\n      request_headers  LONGTEXT  NULL     COMMENT 'Request headers (JSON)',\n      request_body     LONGTEXT  NULL     COMMENT 'Request body',\n      response_type    VARCHAR(10) NOT NULL COMMENT 'Response content type',\n      status_code      INT         NOT NULL COMMENT 'HTTP status code',\n      response_headers LONGTEXT   NULL     COMMENT 'Response headers (JSON)',\n      response_body    LONGTEXT   NOT NULL COMMENT 'Response body',\n      created_at       DATETIME(3) NOT NULL COMMENT 'Record creation timestamp',\n      UNIQUE INDEX idx_unique (method, endpoint, status_code, url_hash)\n    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci\n  `)\n}\n","/**\n * Response recorder for @book000/pixivts-db-mysql.\n *\n * `createResponseRecorder()` returns a `{ interceptor, db, close }` bundle:\n *   - `interceptor` — pass to `PixivClient.of(token, { onResponse: interceptor })`\n *   - `db` — the raw Drizzle instance for custom queries\n *   - `close()` — shuts down the connection pool\n *\n * The recorder uses Drizzle ORM's `onDuplicateKeyUpdate` to silently ignore\n * duplicate entries (same method + endpoint + statusCode + urlHash).\n */\n\nimport crypto from 'node:crypto'\nimport { and, count, desc, eq, gte, sql } from 'drizzle-orm'\nimport type { ResponseInterceptor, ResponseRecord } from '@book000/pixivts'\nimport { createDbConnection, type ConnectionOptions, type DbInstance } from './connection'\nimport { responsesTable, type ResponseRow } from './schema'\nimport { bootstrapSchema } from './migrations'\n\n// ---------------------------------------------------------------------------\n// Result bundle\n// ---------------------------------------------------------------------------\n\n/** The object returned by `createResponseRecorder()`. */\nexport interface RecorderBundle {\n  /**\n   * Response interceptor — pass directly to `PixivClient.of()` as\n   * the `onResponse` option.\n   */\n  interceptor: ResponseInterceptor\n\n  /** Drizzle ORM database instance for custom queries. */\n  db: DbInstance\n\n  /** Closes the underlying connection pool. */\n  close(): Promise<void>\n}\n\n// ---------------------------------------------------------------------------\n// Options\n// ---------------------------------------------------------------------------\n\n/** Options for `createResponseRecorder()`. */\nexport interface RecorderOptions extends ConnectionOptions {\n  /**\n   * If `true`, runs `CREATE TABLE IF NOT EXISTS` before returning.\n   * Useful for first-run bootstrapping without a separate migration step.\n   *\n   * @default false\n   */\n  bootstrap?: boolean\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\n/**\n * Creates a response recorder that persists every pixiv API response to MySQL.\n *\n * @param opts - Connection and bootstrapping options\n * @returns `{ interceptor, db, close }`\n *\n * @example\n * ```ts\n * const { interceptor, close } = await createResponseRecorder({\n *   host: 'localhost',\n *   database: 'pixivts',\n *   bootstrap: true,\n * })\n * const client = await PixivClient.of(token, { onResponse: interceptor })\n * // ...\n * await close()\n * ```\n */\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\nfunction ninetyDaysAgo(): Date {\n  return new Date(Date.now() - 90 * 24 * 60 * 60 * 1000)\n}\n\n// ---------------------------------------------------------------------------\n// Core DB helpers (exported for testing)\n// ---------------------------------------------------------------------------\n\n/**\n * Inserts a response record into the database.\n *\n * If the unique composite index fires (duplicate method + endpoint + statusCode\n * + urlHash), the insert is silently ignored via `ON DUPLICATE KEY UPDATE id = id`.\n *\n * @param db - Drizzle ORM database instance\n * @param record - Response record from the HTTP client interceptor\n */\nexport async function addResponse(\n  db: DbInstance,\n  record: ResponseRecord\n): Promise<void> {\n  // Hash the URL if present; fall back to \"method:endpoint\" so the column is never empty.\n  const urlToHash = record.url ?? `${record.method}:${record.endpoint}`\n  const urlHash = crypto\n    .createHash('sha256')\n    .update(urlToHash)\n    .digest('hex')\n\n  await db\n    .insert(responsesTable)\n    .values({\n      method: record.method,\n      endpoint: record.endpoint,\n      url: record.url,\n      urlHash,\n      requestHeaders: record.requestHeaders,\n      requestBody: record.requestBody,\n      responseType: record.responseType,\n      statusCode: record.statusCode,\n      responseHeaders: record.responseHeaders,\n      responseBody: record.responseBody,\n      createdAt: new Date(),\n    })\n    .onDuplicateKeyUpdate({ set: { id: sql`id` } })\n}\n\n/**\n * Creates a `RecorderBundle` from an existing Drizzle instance.\n *\n * Useful for testing — pass a mock `db` and a no-op `close`.\n *\n * @param db - Drizzle ORM database instance\n * @param close - Function that closes the underlying connection\n */\nexport function createRecorderBundle(\n  db: DbInstance,\n  close: () => Promise<void>\n): RecorderBundle {\n  const interceptor: ResponseInterceptor = (record) =>\n    addResponse(db, record)\n\n  return { interceptor, db, close }\n}\n\n/**\n * Creates a response recorder that persists every pixiv API response to MySQL.\n *\n * @param opts - Connection and bootstrapping options\n * @returns `{ interceptor, db, close }`\n *\n * @example\n * ```ts\n * const { interceptor, close } = await createResponseRecorder({\n *   host: 'localhost',\n *   database: 'pixivts',\n *   bootstrap: true,\n * })\n * const client = await PixivClient.of(token, { onResponse: interceptor })\n * // ...\n * await close()\n * ```\n */\nexport async function createResponseRecorder(\n  opts: RecorderOptions\n): Promise<RecorderBundle> {\n  const { pool, db } = createDbConnection(opts)\n\n  if (opts.bootstrap) {\n    await bootstrapSchema(db)\n  }\n\n  return createRecorderBundle(db, () => pool.end())\n}\n\n// ---------------------------------------------------------------------------\n// Query helpers\n// ---------------------------------------------------------------------------\n\n/** Filter criteria for response queries. */\nexport interface ResponseFilter {\n  /** HTTP method to filter by (e.g. `\"GET\"`). Omit to match all methods. */\n  method?: string\n  /** API endpoint path to filter by (e.g. `\"/v1/illust/detail\"`). Omit to match all endpoints. */\n  endpoint?: string\n  /** HTTP status code to filter by (e.g. `200`). Omit to match all status codes. */\n  statusCode?: number\n}\n\n/** Pagination options for `getResponses`. */\nexport interface RangeOptions {\n  /** 1-based page number (default: 1). */\n  page?: number\n  /** Items per page (default: 100). */\n  limit?: number\n}\n\n/**\n * Retrieves response records from the last 90 days.\n *\n * @param db - Drizzle ORM database instance\n * @param filter - Optional filter criteria\n * @param range - Optional pagination options\n * @returns Array of response rows, newest first\n */\nexport async function getResponses(\n  db: DbInstance,\n  filter?: ResponseFilter,\n  range?: RangeOptions\n): Promise<ResponseRow[]> {\n  const since = ninetyDaysAgo()\n  const limit = range?.limit ?? 100\n  const offset = ((range?.page ?? 1) - 1) * limit\n\n  return db\n    .select()\n    .from(responsesTable)\n    .where(\n      and(\n        gte(responsesTable.createdAt, since),\n        filter?.method\n          ? eq(responsesTable.method, filter.method)\n          : undefined,\n        filter?.endpoint\n          ? eq(responsesTable.endpoint, filter.endpoint)\n          : undefined,\n        filter?.statusCode\n          ? eq(responsesTable.statusCode, filter.statusCode)\n          : undefined\n      )\n    )\n    .orderBy(desc(responsesTable.createdAt))\n    .limit(limit)\n    .offset(offset)\n}\n\n/**\n * Returns the total count of response records from the last 90 days.\n *\n * @param db - Drizzle ORM database instance\n * @param filter - Optional filter criteria\n * @returns Total row count matching the filter\n */\nexport async function getResponseCount(\n  db: DbInstance,\n  filter?: ResponseFilter\n): Promise<number> {\n  const since = ninetyDaysAgo()\n  const rows = await db\n    .select({ value: count() })\n    .from(responsesTable)\n    .where(\n      and(\n        gte(responsesTable.createdAt, since),\n        filter?.method\n          ? eq(responsesTable.method, filter.method)\n          : undefined,\n        filter?.endpoint\n          ? eq(responsesTable.endpoint, filter.endpoint)\n          : undefined,\n        filter?.statusCode\n          ? eq(responsesTable.statusCode, filter.statusCode)\n          : undefined\n      )\n    )\n  return rows[0]?.value ?? 0\n}\n\n/** An endpoint with its response count. */\nexport interface EndpointWithCount {\n  /** HTTP method (e.g. `\"GET\"` or `\"POST\"`). */\n  method: string\n  /** API endpoint path (e.g. `\"/v1/illust/detail\"`). */\n  endpoint: string\n  /** HTTP status code returned by the endpoint. */\n  statusCode: number\n  /** Number of recorded responses for this (method, endpoint, statusCode) combination. */\n  count: number\n}\n\n/**\n * Returns all unique (method, endpoint, statusCode) combinations seen in the\n * last 90 days, along with the count of matching records.\n *\n * @param db - Drizzle ORM database instance\n * @returns Endpoints sorted by count descending\n */\nexport async function getEndpoints(db: DbInstance): Promise<EndpointWithCount[]> {\n  const since = ninetyDaysAgo()\n  const rows = await db\n    .select({\n      method: responsesTable.method,\n      endpoint: responsesTable.endpoint,\n      statusCode: responsesTable.statusCode,\n      count: count(),\n    })\n    .from(responsesTable)\n    .where(gte(responsesTable.createdAt, since))\n    .groupBy(\n      responsesTable.method,\n      responsesTable.endpoint,\n      responsesTable.statusCode\n    )\n    .orderBy(desc(count()))\n\n  return rows.map((r) => ({ ...r, count: r.count }))\n}\n"],"mappings":"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"}

package/dist/rolldown-runtime-D7D4PA-g.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@book000/pixivts-db-mysql",
-  "version": "0.60.0",
+  "version": "0.60.2",
   "description": "MySQL response recorder for @book000/pixivts (Drizzle ORM)",
   "keywords": [
     "pixiv",
@@ -46,18 +46,18 @@
     "mysql2": "3.22.5"
   },
   "peerDependencies": {
-    "@book000/pixivts": "0.60.0"
+    "@book000/pixivts": "0.60.2"
   },
   "devDependencies": {
     "@types/node": "24.13.2",
     "@vitest/coverage-v8": "4.1.8",
     "drizzle-kit": "0.31.10",
-    "tsup": "8.5.1",
+    "tsdown": "0.22.2",
     "typescript": "6.0.3",
     "vitest": "4.1.8"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "clean": "rimraf dist",
     "lint": "tsc -p tsconfig.test.json",
     "fix": "echo 'no fix needed'",