@book000/pixivts-db-mysql 0.60.0 → 0.60.1

package/dist/index.cjs

@@ -1,87 +1,146 @@
-'use strict';
-
-var mysql2 = require('drizzle-orm/mysql2');
-var mysql = require('mysql2/promise');
-var mysqlCore = require('drizzle-orm/mysql-core');
-var crypto = require('crypto');
-var drizzleOrm = require('drizzle-orm');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var mysql__default = /*#__PURE__*/_interopDefault(mysql);
-var crypto__default = /*#__PURE__*/_interopDefault(crypto);
-
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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;
 };
-
-// src/schema.ts
-var schema_exports = {};
-__export(schema_exports, {
-  responsesTable: () => responsesTable
-});
-var responsesTable = mysqlCore.mysqlTable(
-  "responses",
-  {
-    /** Auto-increment primary key. */
-    id: mysqlCore.int("id").autoincrement().primaryKey(),
-    /** HTTP method (GET or POST). */
-    method: mysqlCore.varchar("method", { length: 10 }).notNull(),
-    /** API endpoint path (e.g. /v1/illust/detail). */
-    endpoint: mysqlCore.varchar("endpoint", { length: 255 }).notNull(),
-    /** Full request URL (may be null for internal requests). */
-    url: mysqlCore.text("url"),
-    /** SHA-256 hash of the request URL for deduplication. */
-    urlHash: mysqlCore.varchar("url_hash", { length: 255 }).notNull(),
-    /** Serialised request headers (JSON string). */
-    requestHeaders: mysqlCore.longtext("request_headers"),
-    /** Request body (URL-encoded string for POST, null for GET). */
-    requestBody: mysqlCore.longtext("request_body"),
-    /** Response content type ("JSON" or "TEXT"). */
-    responseType: mysqlCore.varchar("response_type", { length: 10 }).notNull(),
-    /** HTTP response status code. */
-    statusCode: mysqlCore.int("status_code").notNull(),
-    /** Serialised response headers (JSON string). */
-    responseHeaders: mysqlCore.longtext("response_headers"),
-    /** Raw response body. */
-    responseBody: mysqlCore.longtext("response_body").notNull(),
-    /** Timestamp when the record was created. */
-    createdAt: mysqlCore.datetime("created_at", { mode: "date", fsp: 3 }).notNull()
-  },
-  (table) => [
-    mysqlCore.uniqueIndex("idx_unique").on(
-      table.method,
-      table.endpoint,
-      table.statusCode,
-      table.urlHash
-    )
-  ]
-);
-
-// src/connection.ts
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let drizzle_orm_mysql2 = require("drizzle-orm/mysql2");
+let mysql2_promise = require("mysql2/promise");
+mysql2_promise = __toESM(mysql2_promise, 1);
+let drizzle_orm_mysql_core = require("drizzle-orm/mysql-core");
+let node_crypto = require("node:crypto");
+node_crypto = __toESM(node_crypto, 1);
+let drizzle_orm = require("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 = (0, drizzle_orm_mysql_core.mysqlTable)("responses", {
+	/** Auto-increment primary key. */
+	id: (0, drizzle_orm_mysql_core.int)("id").autoincrement().primaryKey(),
+	/** HTTP method (GET or POST). */
+	method: (0, drizzle_orm_mysql_core.varchar)("method", { length: 10 }).notNull(),
+	/** API endpoint path (e.g. /v1/illust/detail). */
+	endpoint: (0, drizzle_orm_mysql_core.varchar)("endpoint", { length: 255 }).notNull(),
+	/** Full request URL (may be null for internal requests). */
+	url: (0, drizzle_orm_mysql_core.text)("url"),
+	/** SHA-256 hash of the request URL for deduplication. */
+	urlHash: (0, drizzle_orm_mysql_core.varchar)("url_hash", { length: 255 }).notNull(),
+	/** Serialised request headers (JSON string). */
+	requestHeaders: (0, drizzle_orm_mysql_core.longtext)("request_headers"),
+	/** Request body (URL-encoded string for POST, null for GET). */
+	requestBody: (0, drizzle_orm_mysql_core.longtext)("request_body"),
+	/** Response content type ("JSON" or "TEXT"). */
+	responseType: (0, drizzle_orm_mysql_core.varchar)("response_type", { length: 10 }).notNull(),
+	/** HTTP response status code. */
+	statusCode: (0, drizzle_orm_mysql_core.int)("status_code").notNull(),
+	/** Serialised response headers (JSON string). */
+	responseHeaders: (0, drizzle_orm_mysql_core.longtext)("response_headers"),
+	/** Raw response body. */
+	responseBody: (0, drizzle_orm_mysql_core.longtext)("response_body").notNull(),
+	/** Timestamp when the record was created. */
+	createdAt: (0, drizzle_orm_mysql_core.datetime)("created_at", {
+		mode: "date",
+		fsp: 3
+	}).notNull()
+}, (table) => [(0, drizzle_orm_mysql_core.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__default.default.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 = mysql2.drizzle(pool, { schema: schema_exports, mode: "default" });
-  return { pool, db };
+	const pool = mysql2_promise.default.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: (0, drizzle_orm_mysql2.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(drizzleOrm.sql`
+	await db.execute(drizzle_orm.sql`
     CREATE TABLE IF NOT EXISTS responses (
       id           INT AUTO_INCREMENT PRIMARY KEY COMMENT 'Response ID',
       method       VARCHAR(10)   NOT NULL COMMENT 'HTTP method',
@@ -99,79 +158,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__default.default.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: drizzleOrm.sql`id` } });
+	const urlToHash = record.url ?? `${record.method}:${record.endpoint}`;
+	const urlHash = node_crypto.default.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: drizzle_orm.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(
-    drizzleOrm.and(
-      drizzleOrm.gte(responsesTable.createdAt, since),
-      filter?.method ? drizzleOrm.eq(responsesTable.method, filter.method) : void 0,
-      filter?.endpoint ? drizzleOrm.eq(responsesTable.endpoint, filter.endpoint) : void 0,
-      filter?.statusCode ? drizzleOrm.eq(responsesTable.statusCode, filter.statusCode) : void 0
-    )
-  ).orderBy(drizzleOrm.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((0, drizzle_orm.and)((0, drizzle_orm.gte)(responsesTable.createdAt, since), filter?.method ? (0, drizzle_orm.eq)(responsesTable.method, filter.method) : void 0, filter?.endpoint ? (0, drizzle_orm.eq)(responsesTable.endpoint, filter.endpoint) : void 0, filter?.statusCode ? (0, drizzle_orm.eq)(responsesTable.statusCode, filter.statusCode) : void 0)).orderBy((0, drizzle_orm.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: drizzleOrm.count() }).from(responsesTable).where(
-    drizzleOrm.and(
-      drizzleOrm.gte(responsesTable.createdAt, since),
-      filter?.method ? drizzleOrm.eq(responsesTable.method, filter.method) : void 0,
-      filter?.endpoint ? drizzleOrm.eq(responsesTable.endpoint, filter.endpoint) : void 0,
-      filter?.statusCode ? drizzleOrm.eq(responsesTable.statusCode, filter.statusCode) : void 0
-    )
-  );
-  return rows[0]?.value ?? 0;
+	const since = ninetyDaysAgo();
+	return (await db.select({ value: (0, drizzle_orm.count)() }).from(responsesTable).where((0, drizzle_orm.and)((0, drizzle_orm.gte)(responsesTable.createdAt, since), filter?.method ? (0, drizzle_orm.eq)(responsesTable.method, filter.method) : void 0, filter?.endpoint ? (0, drizzle_orm.eq)(responsesTable.endpoint, filter.endpoint) : void 0, filter?.statusCode ? (0, drizzle_orm.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: drizzleOrm.count()
-  }).from(responsesTable).where(drizzleOrm.gte(responsesTable.createdAt, since)).groupBy(
-    responsesTable.method,
-    responsesTable.endpoint,
-    responsesTable.statusCode
-  ).orderBy(drizzleOrm.desc(drizzleOrm.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: (0, drizzle_orm.count)()
+	}).from(responsesTable).where((0, drizzle_orm.gte)(responsesTable.createdAt, since)).groupBy(responsesTable.method, responsesTable.endpoint, responsesTable.statusCode).orderBy((0, drizzle_orm.desc)((0, drizzle_orm.count)()))).map((r) => ({
+		...r,
+		count: r.count
+	}));
 }
-
+//#endregion
 exports.addResponse = addResponse;
 exports.bootstrapSchema = bootstrapSchema;
 exports.createDbConnection = createDbConnection;