mtgjson-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1840 @@
+// src/booster/simulator.ts
+var BoosterSimulator = class {
+  _conn;
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async _ensure() {
+    await this._conn.ensureViews("sets", "cards");
+  }
+  async _getBoosterConfig(setCode) {
+    await this._ensure();
+    try {
+      const rows = await this._conn.execute(
+        "SELECT booster FROM sets WHERE code = $1",
+        [setCode.toUpperCase()]
+      );
+      if (!rows.length || !rows[0].booster) return null;
+      return rows[0].booster;
+    } catch {
+      return null;
+    }
+  }
+  async availableTypes(setCode) {
+    const config = await this._getBoosterConfig(setCode);
+    if (!config) return [];
+    return Object.keys(config);
+  }
+  async openPack(setCode, boosterType = "draft") {
+    const configs = await this._getBoosterConfig(setCode);
+    if (!configs || !(boosterType in configs)) {
+      throw new Error(
+        `No booster config for set '${setCode}' type '${boosterType}'. Available: ${configs ? Object.keys(configs) : []}`
+      );
+    }
+    const config = configs[boosterType];
+    const packTemplate = pickPack(config.boosters);
+    const sheets = config.sheets;
+    const cardUuids = [];
+    for (const [sheetName, count] of Object.entries(packTemplate.contents)) {
+      if (!(sheetName in sheets)) continue;
+      const sheet = sheets[sheetName];
+      const picked = pickFromSheet(sheet, count);
+      cardUuids.push(...picked);
+    }
+    if (cardUuids.length === 0) return [];
+    await this._conn.ensureViews("cards");
+    const placeholders = cardUuids.map((_, i) => `$${i + 1}`).join(", ");
+    const sql = `SELECT * FROM cards WHERE uuid IN (${placeholders})`;
+    const rows = await this._conn.execute(sql, cardUuids);
+    const uuidToRow = /* @__PURE__ */ new Map();
+    for (const r of rows) {
+      uuidToRow.set(r.uuid, r);
+    }
+    const ordered = [];
+    for (const u of cardUuids) {
+      const row = uuidToRow.get(u);
+      if (row) ordered.push(row);
+    }
+    return ordered;
+  }
+  async openBox(setCode, boosterType = "draft", packs = 36) {
+    const results = [];
+    for (let i = 0; i < packs; i++) {
+      results.push(await this.openPack(setCode, boosterType));
+    }
+    return results;
+  }
+  async sheetContents(setCode, boosterType, sheetName) {
+    const configs = await this._getBoosterConfig(setCode);
+    if (!configs || !(boosterType in configs)) return null;
+    const sheets = configs[boosterType].sheets ?? {};
+    const sheet = sheets[sheetName];
+    if (!sheet) return null;
+    return sheet.cards;
+  }
+};
+function pickPack(boosters) {
+  const weights = boosters.map((b) => b.weight);
+  return weightedChoice(boosters, weights);
+}
+function pickFromSheet(sheet, count) {
+  const cards = sheet.cards;
+  const uuids = Object.keys(cards);
+  const weights = Object.values(cards);
+  const allowDuplicates = sheet.allowDuplicates ?? false;
+  if (allowDuplicates) {
+    const picked2 = [];
+    for (let i = 0; i < count; i++) {
+      picked2.push(weightedChoice(uuids, weights));
+    }
+    return picked2;
+  }
+  if (count >= uuids.length) {
+    const result = [...uuids];
+    shuffle(result);
+    return result;
+  }
+  const picked = [];
+  const remainingUuids = [...uuids];
+  const remainingWeights = [...weights];
+  for (let i = 0; i < Math.min(count, remainingUuids.length); i++) {
+    const choice = weightedChoice(remainingUuids, remainingWeights);
+    picked.push(choice);
+    const idx = remainingUuids.indexOf(choice);
+    remainingUuids.splice(idx, 1);
+    remainingWeights.splice(idx, 1);
+  }
+  return picked;
+}
+function weightedChoice(items, weights) {
+  const totalWeight = weights.reduce((a, b) => a + b, 0);
+  let random = Math.random() * totalWeight;
+  for (let i = 0; i < items.length; i++) {
+    random -= weights[i];
+    if (random <= 0) return items[i];
+  }
+  return items[items.length - 1];
+}
+function shuffle(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+}
+
+// src/cache.ts
+import { createWriteStream } from "fs";
+import { existsSync } from "fs";
+import {
+  mkdir,
+  readFile,
+  rename,
+  rm,
+  unlink,
+  writeFile
+} from "fs/promises";
+import { get as httpsGet } from "https";
+import { join as join2 } from "path";
+import { createGunzip } from "zlib";
+
+// src/config.ts
+import { homedir, platform } from "os";
+import { join } from "path";
+var CDN_BASE = "https://mtgjson.com/api/v5";
+var PARQUET_FILES = {
+  // Flat normalized tables
+  cards: "parquet/cards.parquet",
+  tokens: "parquet/tokens.parquet",
+  sets: "parquet/sets.parquet",
+  card_identifiers: "parquet/cardIdentifiers.parquet",
+  card_legalities: "parquet/cardLegalities.parquet",
+  card_foreign_data: "parquet/cardForeignData.parquet",
+  card_rulings: "parquet/cardRulings.parquet",
+  card_purchase_urls: "parquet/cardPurchaseUrls.parquet",
+  set_translations: "parquet/setTranslations.parquet",
+  token_identifiers: "parquet/tokenIdentifiers.parquet",
+  // Booster tables
+  set_booster_content_weights: "parquet/setBoosterContentWeights.parquet",
+  set_booster_contents: "parquet/setBoosterContents.parquet",
+  set_booster_sheet_cards: "parquet/setBoosterSheetCards.parquet",
+  set_booster_sheets: "parquet/setBoosterSheets.parquet",
+  // Full nested
+  all_printings: "parquet/AllPrintings.parquet",
+  // Prices and SKUs
+  all_prices_today: "parquet/AllPricesToday.parquet",
+  all_prices: "parquet/AllPrices.parquet",
+  tcgplayer_skus: "parquet/TcgplayerSkus.parquet"
+};
+var JSON_FILES = {
+  keywords: "Keywords.json",
+  card_types: "CardTypes.json",
+  deck_list: "DeckList.json",
+  enum_values: "EnumValues.json",
+  meta: "Meta.json"
+};
+var META_URL = `${CDN_BASE}/Meta.json`;
+function defaultCacheDir() {
+  const sys = platform();
+  let base;
+  if (sys === "win32") {
+    base = join(homedir(), "AppData", "Local");
+  } else if (sys === "darwin") {
+    base = join(homedir(), "Library", "Caches");
+  } else {
+    base = join(homedir(), ".cache");
+  }
+  return join(base, "mtgjson-sdk");
+}
+
+// src/cache.ts
+var CacheManager = class {
+  cacheDir;
+  offline;
+  timeout;
+  _remoteVersion = null;
+  _onProgress;
+  constructor(options) {
+    this.cacheDir = options?.cacheDir ?? defaultCacheDir();
+    this.offline = options?.offline ?? false;
+    this.timeout = options?.timeout ?? 12e4;
+    this._onProgress = options?.onProgress ?? null;
+  }
+  async init() {
+    await mkdir(this.cacheDir, { recursive: true });
+  }
+  close() {
+  }
+  async _localVersion() {
+    const versionFile = join2(this.cacheDir, "version.txt");
+    try {
+      return (await readFile(versionFile, "utf-8")).trim();
+    } catch {
+      return null;
+    }
+  }
+  async _saveVersion(version) {
+    await writeFile(join2(this.cacheDir, "version.txt"), version, "utf-8");
+  }
+  async remoteVersion() {
+    if (this._remoteVersion) return this._remoteVersion;
+    if (this.offline) return null;
+    try {
+      const resp = await fetch(META_URL, {
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (!resp.ok) return null;
+      const data = await resp.json();
+      this._remoteVersion = data?.data?.version ?? data?.meta?.version ?? null;
+      return this._remoteVersion;
+    } catch {
+      return null;
+    }
+  }
+  async isStale() {
+    const local = await this._localVersion();
+    const remote = await this.remoteVersion();
+    if (remote === null) return false;
+    if (local === null) return true;
+    return local !== remote;
+  }
+  async _downloadFile(filename, dest) {
+    const url = `${CDN_BASE}/${filename}`;
+    const dir = join2(dest, "..");
+    await mkdir(dir, { recursive: true });
+    const tmpDest = `${dest}.tmp`;
+    try {
+      await new Promise((resolve, reject) => {
+        httpsGet(url, { timeout: this.timeout }, (res) => {
+          if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+            httpsGet(
+              res.headers.location,
+              { timeout: this.timeout },
+              (res2) => {
+                this._handleDownloadResponse(
+                  res2,
+                  tmpDest,
+                  filename,
+                  resolve,
+                  reject
+                );
+              }
+            ).on("error", reject);
+            return;
+          }
+          this._handleDownloadResponse(res, tmpDest, filename, resolve, reject);
+        }).on("error", reject);
+      });
+      await rename(tmpDest, dest);
+    } catch (err) {
+      try {
+        await unlink(tmpDest);
+      } catch {
+      }
+      throw err;
+    }
+  }
+  _handleDownloadResponse(res, tmpDest, filename, resolve, reject) {
+    if (res.statusCode && res.statusCode >= 400) {
+      reject(new Error(`HTTP ${res.statusCode} downloading ${filename}`));
+      res.resume();
+      return;
+    }
+    const total = res.headers["content-length"] ? Number.parseInt(res.headers["content-length"], 10) : null;
+    let downloaded = 0;
+    const ws = createWriteStream(tmpDest);
+    res.on("data", (chunk) => {
+      downloaded += chunk.length;
+      if (this._onProgress) {
+        this._onProgress(filename, downloaded, total);
+      }
+    });
+    res.pipe(ws);
+    ws.on("finish", resolve);
+    ws.on("error", reject);
+    res.on("error", reject);
+  }
+  async ensureParquet(viewName) {
+    const filename = PARQUET_FILES[viewName];
+    if (!filename) throw new Error(`Unknown parquet view: ${viewName}`);
+    const localPath = join2(this.cacheDir, filename);
+    if (!existsSync(localPath) || await this.isStale()) {
+      if (this.offline) {
+        if (existsSync(localPath)) return localPath;
+        throw new Error(
+          `Parquet file ${filename} not cached and offline mode is enabled`
+        );
+      }
+      await this._downloadFile(filename, localPath);
+      const version = await this.remoteVersion();
+      if (version) await this._saveVersion(version);
+    }
+    return localPath;
+  }
+  async ensureJson(name) {
+    const filename = JSON_FILES[name];
+    if (!filename) throw new Error(`Unknown JSON file: ${name}`);
+    const localPath = join2(this.cacheDir, filename);
+    if (!existsSync(localPath) || await this.isStale()) {
+      if (this.offline) {
+        if (existsSync(localPath)) return localPath;
+        throw new Error(
+          `JSON file ${filename} not cached and offline mode is enabled`
+        );
+      }
+      await this._downloadFile(filename, localPath);
+      const version = await this.remoteVersion();
+      if (version) await this._saveVersion(version);
+    }
+    return localPath;
+  }
+  async loadJson(name) {
+    const path = await this.ensureJson(name);
+    try {
+      if (path.endsWith(".gz")) {
+        const compressed = await readFile(path);
+        const decompressed = await new Promise((resolve, reject) => {
+          const gunzip = createGunzip();
+          const chunks = [];
+          gunzip.on("data", (chunk) => chunks.push(chunk));
+          gunzip.on("end", () => resolve(Buffer.concat(chunks)));
+          gunzip.on("error", reject);
+          gunzip.end(compressed);
+        });
+        return JSON.parse(decompressed.toString("utf-8"));
+      }
+      const text = await readFile(path, "utf-8");
+      return JSON.parse(text);
+    } catch (err) {
+      try {
+        await unlink(path);
+      } catch {
+      }
+      throw new Error(
+        `Cache file '${path}' was corrupt and has been removed. Retry to re-download. Original error: ${err}`
+      );
+    }
+  }
+  async clear() {
+    try {
+      await rm(this.cacheDir, { recursive: true, force: true });
+    } catch {
+    }
+    await mkdir(this.cacheDir, { recursive: true });
+  }
+};
+
+// src/connection.ts
+import { unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { DuckDBInstance } from "@duckdb/node-api";
+var STATIC_LIST_COLUMNS = {
+  cards: /* @__PURE__ */ new Set([
+    "artistIds",
+    "attractionLights",
+    "availability",
+    "boosterTypes",
+    "cardParts",
+    "colorIdentity",
+    "colorIndicator",
+    "colors",
+    "finishes",
+    "frameEffects",
+    "keywords",
+    "originalPrintings",
+    "otherFaceIds",
+    "printings",
+    "producedMana",
+    "promoTypes",
+    "rebalancedPrintings",
+    "subsets",
+    "subtypes",
+    "supertypes",
+    "types",
+    "variations"
+  ]),
+  tokens: /* @__PURE__ */ new Set([
+    "artistIds",
+    "availability",
+    "boosterTypes",
+    "colorIdentity",
+    "colorIndicator",
+    "colors",
+    "finishes",
+    "frameEffects",
+    "keywords",
+    "otherFaceIds",
+    "producedMana",
+    "promoTypes",
+    "reverseRelated",
+    "subtypes",
+    "supertypes",
+    "types"
+  ])
+};
+var IGNORED_COLUMNS = /* @__PURE__ */ new Set([
+  "text",
+  "originalText",
+  "flavorText",
+  "printedText",
+  "identifiers",
+  "legalities",
+  "leadershipSkills",
+  "purchaseUrls",
+  "relatedCards",
+  "rulings",
+  "sourceProducts",
+  "foreignData",
+  "translations",
+  "toughness",
+  "status",
+  "format",
+  "uris",
+  "scryfallUri"
+]);
+var JSON_CAST_COLUMNS = /* @__PURE__ */ new Set([
+  "identifiers",
+  "legalities",
+  "leadershipSkills",
+  "purchaseUrls",
+  "relatedCards",
+  "rulings",
+  "sourceProducts",
+  "foreignData",
+  "translations"
+]);
+var Connection = class _Connection {
+  _conn;
+  _instance;
+  _registeredViews = /* @__PURE__ */ new Set();
+  cache;
+  constructor(cache) {
+    this.cache = cache;
+  }
+  static async create(cache) {
+    const conn = new _Connection(cache);
+    conn._instance = await DuckDBInstance.create(":memory:");
+    conn._conn = await conn._instance.connect();
+    return conn;
+  }
+  async close() {
+    if (this._conn) {
+      this._conn.closeSync();
+    }
+  }
+  async _ensureView(viewName) {
+    if (this._registeredViews.has(viewName)) return;
+    const path = await this.cache.ensureParquet(viewName);
+    const pathStr = path.replace(/\\/g, "/");
+    if (viewName === "card_legalities") {
+      await this._registerLegalitiesView(pathStr);
+      return;
+    }
+    const replaceClause = await this._buildCsvReplace(pathStr, viewName);
+    await this._run(
+      `CREATE OR REPLACE VIEW ${viewName} AS SELECT *${replaceClause} FROM read_parquet('${pathStr}')`
+    );
+    this._registeredViews.add(viewName);
+  }
+  async _buildCsvReplace(pathStr, viewName) {
+    const reader = await this._conn.runAndReadAll(
+      `SELECT column_name, column_type FROM (DESCRIBE SELECT * FROM read_parquet('${pathStr}'))`
+    );
+    const rows = reader.getRowObjects();
+    const schema = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      schema.set(row.column_name, row.column_type);
+    }
+    const candidates = /* @__PURE__ */ new Set();
+    if (STATIC_LIST_COLUMNS[viewName]) {
+      for (const col of STATIC_LIST_COLUMNS[viewName]) {
+        candidates.add(col);
+      }
+    }
+    for (const [col, dtype] of schema) {
+      if (dtype !== "VARCHAR") continue;
+      if (IGNORED_COLUMNS.has(col)) continue;
+      if (col.endsWith("s")) candidates.add(col);
+    }
+    const finalCols = [...candidates].filter((col) => schema.get(col) === "VARCHAR").sort();
+    const exprs = [];
+    for (const col of finalCols) {
+      exprs.push(
+        `CASE WHEN "${col}" IS NULL OR TRIM("${col}") = '' THEN []::VARCHAR[] ELSE string_split("${col}", ', ') END AS "${col}"`
+      );
+    }
+    const jsonCols = [...JSON_CAST_COLUMNS].sort();
+    for (const col of jsonCols) {
+      if (schema.get(col) === "VARCHAR") {
+        exprs.push(`TRY_CAST("${col}" AS JSON) AS "${col}"`);
+      }
+    }
+    if (exprs.length === 0) return "";
+    return ` REPLACE (${exprs.join(", ")})`;
+  }
+  async _registerLegalitiesView(pathStr) {
+    const reader = await this._conn.runAndReadAll(
+      `SELECT column_name FROM (DESCRIBE SELECT * FROM read_parquet('${pathStr}'))`
+    );
+    const allCols = reader.getRowObjects().map((r) => r.column_name);
+    const staticCols = /* @__PURE__ */ new Set(["uuid"]);
+    const formatCols = allCols.filter((c) => !staticCols.has(c));
+    if (formatCols.length === 0) {
+      await this._run(
+        `CREATE OR REPLACE VIEW card_legalities AS SELECT * FROM read_parquet('${pathStr}')`
+      );
+    } else {
+      const colsSql = formatCols.map((c) => `"${c}"`).join(", ");
+      await this._run(
+        `CREATE OR REPLACE VIEW card_legalities AS SELECT uuid, format, status FROM (  UNPIVOT (SELECT * FROM read_parquet('${pathStr}'))  ON ${colsSql}  INTO NAME format VALUE status) WHERE status IS NOT NULL`
+      );
+    }
+    this._registeredViews.add("card_legalities");
+  }
+  async registerTableFromData(tableName, data) {
+    if (data.length === 0) return;
+    await this._run(`DROP TABLE IF EXISTS ${tableName}`);
+    const tmpPath = join3(tmpdir(), `mtgjson_${tableName}_${Date.now()}.json`);
+    try {
+      writeFileSync(tmpPath, JSON.stringify(data), "utf-8");
+      const fwd = tmpPath.replace(/\\/g, "/");
+      await this._run(
+        `CREATE TABLE ${tableName} AS SELECT * FROM read_json_auto('${fwd}')`
+      );
+    } finally {
+      try {
+        unlinkSync(tmpPath);
+      } catch {
+      }
+    }
+    this._registeredViews.add(tableName);
+  }
+  async registerTableFromNdjson(tableName, ndjsonPath) {
+    await this._run(`DROP TABLE IF EXISTS ${tableName}`);
+    const fwd = ndjsonPath.replace(/\\/g, "/");
+    await this._run(
+      `CREATE TABLE ${tableName} AS SELECT * FROM read_json_auto('${fwd}', format='newline_delimited')`
+    );
+    this._registeredViews.add(tableName);
+  }
+  async ensureViews(...viewNames) {
+    for (const name of viewNames) {
+      await this._ensureView(name);
+    }
+  }
+  async execute(sql, params) {
+    const reader = await this._runWithParams(sql, params);
+    const rows = reader.getRowObjects();
+    return rows.map((row) => coerceValues(row));
+  }
+  async executeJson(sql, params) {
+    const wrapped = `SELECT to_json(list(sub)) FROM (${sql}) sub`;
+    const reader = await this._runWithParams(wrapped, params);
+    const rows = reader.getRows();
+    if (!rows || rows.length === 0 || rows[0][0] == null) return "[]";
+    return String(rows[0][0]);
+  }
+  async executeScalar(sql, params) {
+    const reader = await this._runWithParams(sql, params);
+    const rows = reader.getRows();
+    if (!rows || rows.length === 0) return null;
+    const val = rows[0][0] ?? null;
+    if (typeof val === "bigint") return Number(val);
+    return val;
+  }
+  get raw() {
+    return this._conn;
+  }
+  async _run(sql) {
+    await this._conn.run(sql);
+  }
+  async _runWithParams(sql, params) {
+    if (params && params.length > 0) {
+      const stmt = await this._conn.prepare(sql);
+      for (let i = 0; i < params.length; i++) {
+        const val = params[i];
+        if (typeof val === "string") {
+          stmt.bindVarchar(i + 1, val);
+        } else if (typeof val === "number") {
+          if (Number.isInteger(val)) {
+            stmt.bindInteger(i + 1, val);
+          } else {
+            stmt.bindDouble(i + 1, val);
+          }
+        } else if (typeof val === "boolean") {
+          stmt.bindBoolean(i + 1, val);
+        } else if (val === null || val === void 0) {
+          stmt.bindNull(i + 1);
+        } else {
+          stmt.bindVarchar(i + 1, String(val));
+        }
+      }
+      return await stmt.runAndReadAll();
+    }
+    return await this._conn.runAndReadAll(sql);
+  }
+};
+function coerceValues(val) {
+  if (val instanceof Date) {
+    return val.toISOString();
+  }
+  if (typeof val === "bigint") {
+    return Number(val);
+  }
+  if (Array.isArray(val)) {
+    return val.map(coerceValues);
+  }
+  if (val !== null && typeof val === "object") {
+    const obj = val;
+    if ("items" in obj && Array.isArray(obj.items)) {
+      return obj.items.map(coerceValues);
+    }
+    if ("days" in obj && typeof obj.days === "number" && Object.keys(obj).length === 1) {
+      const ms = obj.days * 864e5;
+      return new Date(ms).toISOString().slice(0, 10);
+    }
+    if ("micros" in obj && typeof obj.micros === "bigint" && Object.keys(obj).length === 1) {
+      const ms = Number(obj.micros / 1000n);
+      return new Date(ms).toISOString();
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      out[k] = coerceValues(v);
+    }
+    return out;
+  }
+  return val;
+}
+
+// src/sql-builder.ts
+var SQLBuilder = class {
+  _select = ["*"];
+  _distinct = false;
+  _from;
+  _joins = [];
+  /** WHERE clauses (public for direct manipulation by query modules). */
+  _where = [];
+  /** Bound parameter values (public for direct manipulation by query modules). */
+  _params = [];
+  _groupBy = [];
+  _having = [];
+  _orderBy = [];
+  _limit = null;
+  _offset = null;
+  constructor(baseTable) {
+    this._from = baseTable;
+  }
+  select(...columns) {
+    this._select = columns;
+    return this;
+  }
+  distinct() {
+    this._distinct = true;
+    return this;
+  }
+  join(clause) {
+    this._joins.push(clause);
+    return this;
+  }
+  where(condition, ...params) {
+    const offset = this._params.length;
+    let remapped = condition;
+    for (let i = params.length; i >= 1; i--) {
+      remapped = remapped.replaceAll(`$${i}`, `$${offset + i}`);
+    }
+    this._where.push(remapped);
+    this._params.push(...params);
+    return this;
+  }
+  whereLike(column, value) {
+    const idx = this._params.length + 1;
+    this._where.push(`LOWER(${column}) LIKE LOWER($${idx})`);
+    this._params.push(value);
+    return this;
+  }
+  whereIn(column, values) {
+    if (values.length === 0) {
+      this._where.push("FALSE");
+      return this;
+    }
+    const placeholders = [];
+    for (const v of values) {
+      const idx = this._params.length + 1;
+      placeholders.push(`$${idx}`);
+      this._params.push(v);
+    }
+    this._where.push(`${column} IN (${placeholders.join(", ")})`);
+    return this;
+  }
+  whereEq(column, value) {
+    const idx = this._params.length + 1;
+    this._where.push(`${column} = $${idx}`);
+    this._params.push(value);
+    return this;
+  }
+  whereGte(column, value) {
+    const idx = this._params.length + 1;
+    this._where.push(`${column} >= $${idx}`);
+    this._params.push(value);
+    return this;
+  }
+  whereLte(column, value) {
+    const idx = this._params.length + 1;
+    this._where.push(`${column} <= $${idx}`);
+    this._params.push(value);
+    return this;
+  }
+  whereRegex(column, pattern) {
+    const idx = this._params.length + 1;
+    this._where.push(`regexp_matches(${column}, $${idx})`);
+    this._params.push(pattern);
+    return this;
+  }
+  whereFuzzy(column, value, threshold = 0.8) {
+    if (typeof threshold !== "number" || threshold < 0 || threshold > 1) {
+      throw new Error(
+        `threshold must be a number between 0 and 1, got ${threshold}`
+      );
+    }
+    const idx = this._params.length + 1;
+    this._where.push(
+      `jaro_winkler_similarity(${column}, $${idx}) > ${threshold}`
+    );
+    this._params.push(value);
+    return this;
+  }
+  whereOr(...conditions) {
+    if (conditions.length === 0) return this;
+    const orParts = [];
+    for (const [cond, param] of conditions) {
+      const idx = this._params.length + 1;
+      const remapped = cond.replaceAll("$1", `$${idx}`);
+      orParts.push(remapped);
+      this._params.push(param);
+    }
+    this._where.push(`(${orParts.join(" OR ")})`);
+    return this;
+  }
+  groupBy(...columns) {
+    this._groupBy.push(...columns);
+    return this;
+  }
+  having(condition, ...params) {
+    const offset = this._params.length;
+    let remapped = condition;
+    for (let i = params.length; i >= 1; i--) {
+      remapped = remapped.replaceAll(`$${i}`, `$${offset + i}`);
+    }
+    this._having.push(remapped);
+    this._params.push(...params);
+    return this;
+  }
+  orderBy(...clauses) {
+    this._orderBy.push(...clauses);
+    return this;
+  }
+  limit(n) {
+    if (!Number.isInteger(n) || n < 0) {
+      throw new TypeError(`limit must be a non-negative integer, got ${n}`);
+    }
+    this._limit = n;
+    return this;
+  }
+  offset(n) {
+    if (!Number.isInteger(n) || n < 0) {
+      throw new TypeError(`offset must be a non-negative integer, got ${n}`);
+    }
+    this._offset = n;
+    return this;
+  }
+  build() {
+    const distinctStr = this._distinct ? "DISTINCT " : "";
+    const parts = [
+      `SELECT ${distinctStr}${this._select.join(", ")}`,
+      `FROM ${this._from}`
+    ];
+    for (const j of this._joins) {
+      parts.push(j);
+    }
+    if (this._where.length > 0) {
+      parts.push(`WHERE ${this._where.join(" AND ")}`);
+    }
+    if (this._groupBy.length > 0) {
+      parts.push(`GROUP BY ${this._groupBy.join(", ")}`);
+    }
+    if (this._having.length > 0) {
+      parts.push(`HAVING ${this._having.join(" AND ")}`);
+    }
+    if (this._orderBy.length > 0) {
+      parts.push(`ORDER BY ${this._orderBy.join(", ")}`);
+    }
+    if (this._limit !== null) {
+      parts.push(`LIMIT ${this._limit}`);
+    }
+    if (this._offset !== null) {
+      parts.push(`OFFSET ${this._offset}`);
+    }
+    return [parts.join("\n"), this._params];
+  }
+};
+
+// src/queries/cards.ts
+var CardQuery = class {
+  _conn;
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async _ensure() {
+    await this._conn.ensureViews("cards");
+  }
+  async getByUuid(uuid) {
+    await this._ensure();
+    const rows = await this._conn.execute(
+      "SELECT * FROM cards WHERE uuid = $1",
+      [uuid]
+    );
+    return rows[0] ?? null;
+  }
+  async getByUuids(uuids) {
+    if (uuids.length === 0) return [];
+    await this._ensure();
+    const q = new SQLBuilder("cards").whereIn("uuid", uuids);
+    const [sql, params] = q.build();
+    return await this._conn.execute(sql, params);
+  }
+  async getByName(name, options) {
+    await this._ensure();
+    const q = new SQLBuilder("cards").whereEq("name", name);
+    if (options?.setCode) q.whereEq("setCode", options.setCode);
+    q.orderBy("setCode DESC", "number ASC");
+    const [sql, params] = q.build();
+    return await this._conn.execute(sql, params);
+  }
+  async search(options) {
+    await this._ensure();
+    const q = new SQLBuilder("cards");
+    const opts = options ?? {};
+    const limit = opts.limit ?? 100;
+    const offset = opts.offset ?? 0;
+    if (opts.name) {
+      if (opts.name.includes("%")) {
+        q.whereLike("name", opts.name);
+      } else {
+        q.whereEq("name", opts.name);
+      }
+    }
+    if (opts.fuzzyName) {
+      q.whereFuzzy("cards.name", opts.fuzzyName, 0.8);
+    }
+    if (opts.setCode) q.whereEq("setCode", opts.setCode);
+    if (opts.rarity) q.whereEq("rarity", opts.rarity);
+    if (opts.manaValue !== void 0) q.whereEq("manaValue", opts.manaValue);
+    if (opts.manaValueLte !== void 0)
+      q.whereLte("manaValue", opts.manaValueLte);
+    if (opts.manaValueGte !== void 0)
+      q.whereGte("manaValue", opts.manaValueGte);
+    if (opts.text) q.whereLike("text", `%${opts.text}%`);
+    if (opts.textRegex) q.whereRegex("text", opts.textRegex);
+    if (opts.types) q.whereLike("type", `%${opts.types}%`);
+    if (opts.power) q.whereEq("power", opts.power);
+    if (opts.toughness) q.whereEq("toughness", opts.toughness);
+    if (opts.artist) q.whereLike("artist", `%${opts.artist}%`);
+    if (opts.language) q.whereEq("language", opts.language);
+    if (opts.layout) q.whereEq("layout", opts.layout);
+    if (opts.isPromo !== void 0) q.whereEq("isPromo", opts.isPromo);
+    if (opts.colors) {
+      for (const color of opts.colors) {
+        const idx = q._params.length + 1;
+        q._where.push(`list_contains(colors, $${idx})`);
+        q._params.push(color);
+      }
+    }
+    if (opts.colorIdentity) {
+      for (const color of opts.colorIdentity) {
+        const idx = q._params.length + 1;
+        q._where.push(`list_contains(colorIdentity, $${idx})`);
+        q._params.push(color);
+      }
+    }
+    if (opts.keyword) {
+      const idx = q._params.length + 1;
+      q._where.push(`list_contains(keywords, $${idx})`);
+      q._params.push(opts.keyword);
+    }
+    if (opts.availability) {
+      const idx = q._params.length + 1;
+      q._where.push(`list_contains(availability, $${idx})`);
+      q._params.push(opts.availability);
+    }
+    if (opts.localizedName) {
+      await this._conn.ensureViews("card_foreign_data");
+      q.select("cards.*");
+      q.join("JOIN card_foreign_data cfd ON cards.uuid = cfd.uuid");
+      if (opts.localizedName.includes("%")) {
+        q.whereLike("cfd.name", opts.localizedName);
+      } else {
+        q.whereEq("cfd.name", opts.localizedName);
+      }
+    }
+    if (opts.legalIn) {
+      await this._conn.ensureViews("card_legalities");
+      q.join("JOIN card_legalities cl ON cards.uuid = cl.uuid");
+      q.whereEq("cl.format", opts.legalIn);
+      q.whereEq("cl.status", "Legal");
+    }
+    if (opts.setType) {
+      await this._conn.ensureViews("sets");
+      q.select("cards.*");
+      q.join("JOIN sets s ON cards.setCode = s.code");
+      q.whereEq("s.type", opts.setType);
+    }
+    if (opts.fuzzyName) {
+      const simIdx = q._params.length + 1;
+      q._params.push(opts.fuzzyName);
+      q.orderBy(
+        `jaro_winkler_similarity(cards.name, $${simIdx}) DESC`,
+        "cards.number ASC"
+      );
+    } else {
+      q.orderBy("cards.name ASC", "cards.number ASC");
+    }
+    q.limit(limit).offset(offset);
+    const [sql, params] = q.build();
+    return await this._conn.execute(sql, params);
+  }
+  async getPrintings(name) {
+    return this.getByName(name);
+  }
+  async getAtomic(name) {
+    await this._ensure();
+    const atomicCols = [
+      "name",
+      "asciiName",
+      "faceName",
+      "type",
+      "types",
+      "subtypes",
+      "supertypes",
+      "colors",
+      "colorIdentity",
+      "colorIndicator",
+      "producedMana",
+      "manaCost",
+      "text",
+      "layout",
+      "side",
+      "power",
+      "toughness",
+      "loyalty",
+      "keywords",
+      "isFunny",
+      "edhrecSaltiness",
+      "subsets",
+      "manaValue",
+      "faceConvertedManaCost",
+      "faceManaValue",
+      "defense",
+      "hand",
+      "life",
+      "edhrecRank",
+      "hasAlternativeDeckLimit",
+      "isReserved",
+      "isGameChanger",
+      "printings",
+      "leadershipSkills",
+      "relatedCards"
+    ];
+    const q = new SQLBuilder("cards");
+    q.select(...atomicCols);
+    q.whereEq("name", name);
+    q.orderBy(
+      "isFunny ASC NULLS FIRST",
+      "isOnlineOnly ASC NULLS FIRST",
+      "side ASC NULLS FIRST"
+    );
+    const [sql, params] = q.build();
+    let rows = await this._conn.execute(sql, params);
+    if (rows.length === 0) {
+      const q2 = new SQLBuilder("cards");
+      q2.select(...atomicCols);
+      q2.where("CAST(faceName AS VARCHAR) = $1", name);
+      q2.orderBy(
+        "isFunny ASC NULLS FIRST",
+        "isOnlineOnly ASC NULLS FIRST",
+        "side ASC NULLS FIRST"
+      );
+      const [sql2, params2] = q2.build();
+      rows = await this._conn.execute(sql2, params2);
+    }
+    if (rows.length === 0) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const r of rows) {
+      const key = `${r.name ?? ""}|${r.faceName ?? ""}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        unique.push(r);
+      }
+    }
+    return unique;
+  }
+  async findByScryfallId(scryfallId) {
+    await this._conn.ensureViews("cards", "card_identifiers");
+    const sql = "SELECT c.* FROM cards c JOIN card_identifiers ci ON c.uuid = ci.uuid WHERE ci.scryfallId = $1";
+    return await this._conn.execute(sql, [scryfallId]);
+  }
+  async random(count = 1) {
+    await this._ensure();
+    const sql = `SELECT * FROM cards USING SAMPLE ${count}`;
+    return await this._conn.execute(sql);
+  }
+  async count(filters) {
+    await this._ensure();
+    if (!filters || Object.keys(filters).length === 0) {
+      return await this._conn.executeScalar(
+        "SELECT COUNT(*) FROM cards"
+      ) ?? 0;
+    }
+    const q = new SQLBuilder("cards").select("COUNT(*)");
+    for (const [col, val] of Object.entries(filters)) {
+      q.whereEq(col, val);
+    }
+    const [sql, params] = q.build();
+    return await this._conn.executeScalar(sql, params) ?? 0;
+  }
+};
+
+// src/queries/sets.ts
+var SetQuery = class {
+  _conn;
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async _ensure() {
+    await this._conn.ensureViews("sets");
+  }
+  async get(code) {
+    await this._ensure();
+    const rows = await this._conn.execute(
+      "SELECT * FROM sets WHERE code = $1",
+      [code.toUpperCase()]
+    );
+    return rows[0] ?? null;
+  }
+  async list(options) {
+    await this._ensure();
+    const q = new SQLBuilder("sets");
+    if (options?.setType) q.whereEq("type", options.setType);
+    if (options?.name) {
+      if (options.name.includes("%")) {
+        q.whereLike("name", options.name);
+      } else {
+        q.whereEq("name", options.name);
+      }
+    }
+    q.orderBy("releaseDate DESC");
+    q.limit(options?.limit ?? 1e3).offset(options?.offset ?? 0);
+    const [sql, params] = q.build();
+    return await this._conn.execute(sql, params);
+  }
+  async search(options) {
+    await this._ensure();
+    const q = new SQLBuilder("sets");
+    if (options?.name) q.whereLike("name", `%${options.name}%`);
+    if (options?.setType) q.whereEq("type", options.setType);
+    if (options?.block) q.whereLike("block", `%${options.block}%`);
+    if (options?.releaseYear) {
+      const idx = q._params.length + 1;
+      q._where.push(`EXTRACT(YEAR FROM CAST(releaseDate AS DATE)) = $${idx}`);
+      q._params.push(options.releaseYear);
+    }
+    q.orderBy("releaseDate DESC");
+    q.limit(options?.limit ?? 100);
+    const [sql, params] = q.build();
+    return await this._conn.execute(sql, params);
+  }
+  async getFinancialSummary(setCode, options) {
+    await this._conn.ensureViews("cards", "all_prices_today");
+    const provider = options?.provider ?? "tcgplayer";
+    const currency = options?.currency ?? "USD";
+    const finish = options?.finish ?? "normal";
+    const priceType = options?.priceType ?? "retail";
+    const sql = `
+			SELECT
+				COUNT(DISTINCT c.uuid) AS card_count,
+				ROUND(SUM(p.price), 2) AS total_value,
+				ROUND(AVG(p.price), 2) AS avg_value,
+				MIN(p.price) AS min_value,
+				MAX(p.price) AS max_price,
+				MAX(p.date) AS date
+			FROM cards c
+			JOIN all_prices_today p ON c.uuid = p.uuid
+			WHERE c.setCode = $1
+			  AND p.provider = $2
+			  AND p.currency = $3
+			  AND p.finish = $4
+			  AND p.price_type = $5
+			  AND p.date = (SELECT MAX(p2.date) FROM all_prices_today p2)
+		`;
+    const rows = await this._conn.execute(sql, [
+      setCode.toUpperCase(),
+      provider,
+      currency,
+      finish,
+      priceType
+    ]);
+    if (!rows.length || rows[0].card_count === 0) return null;
+    return rows[0];
+  }
+  async count() {
+    await this._ensure();
+    return await this._conn.executeScalar(
+      "SELECT COUNT(*) FROM sets"
+    ) ?? 0;
+  }
+};
+
+// src/queries/tokens.ts
+var TokenQuery = class {
+  _conn;
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async _ensure() {
+    await this._conn.ensureViews("tokens");
+  }
+  async getByUuid(uuid) {
+    await this._ensure();
+    const rows = await this._conn.execute(
+      "SELECT * FROM tokens WHERE uuid = $1",
+      [uuid]
+    );
+    return rows[0] ?? null;
+  }
+  async getByUuids(uuids) {
+    if (uuids.length === 0) return [];
+    await this._ensure();
+    const q = new SQLBuilder("tokens").whereIn("uuid", uuids);
+    const [sql, params] = q.build();
+    return await this._conn.execute(sql, params);
+  }
+  async getByName(name, options) {
+    await this._ensure();
+    const q = new SQLBuilder("tokens").whereEq("name", name);
+    if (options?.setCode) q.whereEq("setCode", options.setCode);
+    q.orderBy("setCode DESC", "number ASC");
+    const [sql, params] = q.build();
+    return await this._conn.execute(sql, params);
+  }
+  async search(options) {
+    await this._ensure();
+    const q = new SQLBuilder("tokens");
+    if (options?.name) {
+      if (options.name.includes("%")) {
+        q.whereLike("name", options.name);
+      } else {
+        q.whereEq("name", options.name);
+      }
+    }
+    if (options?.setCode) q.whereEq("setCode", options.setCode);
+    if (options?.types) q.whereLike("type", `%${options.types}%`);
+    if (options?.artist) q.whereLike("artist", `%${options.artist}%`);
+    if (options?.colors) {
+      for (const color of options.colors) {
+        const idx = q._params.length + 1;
+        q._where.push(`list_contains(colors, $${idx})`);
+        q._params.push(color);
+      }
+    }
+    q.orderBy("name ASC", "number ASC");
+    q.limit(options?.limit ?? 100).offset(options?.offset ?? 0);
+    const [sql, params] = q.build();
+    return await this._conn.execute(sql, params);
+  }
+  async forSet(setCode) {
+    return this.search({ setCode, limit: 1e3 });
+  }
+  async count(filters) {
+    await this._ensure();
+    if (!filters || Object.keys(filters).length === 0) {
+      return await this._conn.executeScalar(
+        "SELECT COUNT(*) FROM tokens"
+      ) ?? 0;
+    }
+    const q = new SQLBuilder("tokens").select("COUNT(*)");
+    for (const [col, val] of Object.entries(filters)) {
+      q.whereEq(col, val);
+    }
+    const [sql, params] = q.build();
+    return await this._conn.executeScalar(sql, params) ?? 0;
+  }
+};
+
+// src/queries/prices.ts
+var PriceQuery = class {
+  _conn;
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async _ensure() {
+    await this._conn.ensureViews("all_prices_today");
+  }
+  async get(uuid) {
+    await this._ensure();
+    const rows = await this._conn.execute(
+      "SELECT * FROM all_prices_today WHERE uuid = $1 ORDER BY source, provider, price_type, finish, date",
+      [uuid]
+    );
+    if (rows.length === 0) return null;
+    const result = {};
+    for (const r of rows) {
+      const srcKey = r.source;
+      if (!result[srcKey]) result[srcKey] = {};
+      const src = result[srcKey];
+      const provKey = r.provider;
+      if (!src[provKey]) src[provKey] = { currency: r.currency ?? "USD" };
+      const prov = src[provKey];
+      const catKey = r.price_type;
+      if (!prov[catKey]) prov[catKey] = {};
+      const cat = prov[catKey];
+      const finKey = r.finish;
+      if (!cat[finKey]) cat[finKey] = {};
+      const fin = cat[finKey];
+      fin[r.date] = r.price;
+    }
+    return result;
+  }
+  async today(uuid, options) {
+    await this._ensure();
+    const parts = [
+      "SELECT * FROM all_prices_today",
+      "WHERE uuid = $1",
+      "AND date = (SELECT MAX(p2.date) FROM all_prices_today p2 WHERE p2.uuid = $1)"
+    ];
+    const params = [uuid];
+    let idx = 2;
+    if (options?.provider) {
+      parts.push(`AND provider = $${idx}`);
+      params.push(options.provider);
+      idx++;
+    }
+    if (options?.finish) {
+      parts.push(`AND finish = $${idx}`);
+      params.push(options.finish);
+      idx++;
+    }
+    if (options?.priceType) {
+      parts.push(`AND price_type = $${idx}`);
+      params.push(options.priceType);
+      idx++;
+    }
+    return this._conn.execute(parts.join(" "), params);
+  }
+  async history(uuid, options) {
+    await this._conn.ensureViews("all_prices");
+    const parts = ["SELECT * FROM all_prices WHERE uuid = $1"];
+    const params = [uuid];
+    let idx = 2;
+    if (options?.provider) {
+      parts.push(`AND provider = $${idx}`);
+      params.push(options.provider);
+      idx++;
+    }
+    if (options?.finish) {
+      parts.push(`AND finish = $${idx}`);
+      params.push(options.finish);
+      idx++;
+    }
+    if (options?.priceType) {
+      parts.push(`AND price_type = $${idx}`);
+      params.push(options.priceType);
+      idx++;
+    }
+    if (options?.dateFrom) {
+      parts.push(`AND date >= $${idx}`);
+      params.push(options.dateFrom);
+      idx++;
+    }
+    if (options?.dateTo) {
+      parts.push(`AND date <= $${idx}`);
+      params.push(options.dateTo);
+      idx++;
+    }
+    parts.push("ORDER BY date ASC");
+    return this._conn.execute(parts.join(" "), params);
+  }
+  async priceTrend(uuid, options) {
+    await this._conn.ensureViews("all_prices");
+    const priceType = options?.priceType ?? "retail";
+    const parts = [
+      "SELECT",
+      "  MIN(price) AS min_price,",
+      "  MAX(price) AS max_price,",
+      "  ROUND(AVG(price), 2) AS avg_price,",
+      "  MIN(date) AS first_date,",
+      "  MAX(date) AS last_date,",
+      "  COUNT(*) AS data_points",
+      "FROM all_prices",
+      "WHERE uuid = $1 AND price_type = $2"
+    ];
+    const params = [uuid, priceType];
+    let idx = 3;
+    if (options?.provider) {
+      parts.push(`AND provider = $${idx}`);
+      params.push(options.provider);
+      idx++;
+    }
+    if (options?.finish) {
+      parts.push(`AND finish = $${idx}`);
+      params.push(options.finish);
+      idx++;
+    }
+    const rows = await this._conn.execute(parts.join(" "), params);
+    if (!rows.length || rows[0].data_points === 0) return null;
+    return rows[0];
+  }
+  async cheapestPrinting(name, options) {
+    await this._ensure();
+    await this._conn.ensureViews("cards");
+    const provider = options?.provider ?? "tcgplayer";
+    const finish = options?.finish ?? "normal";
+    const priceType = options?.priceType ?? "retail";
+    const sql = "SELECT c.uuid, c.setCode, c.number, p.price, p.date FROM cards c JOIN all_prices_today p ON c.uuid = p.uuid WHERE c.name = $1 AND p.provider = $2 AND p.finish = $3 AND p.price_type = $4 AND p.date = (SELECT MAX(p2.date) FROM all_prices_today p2 WHERE p2.uuid = c.uuid AND p2.provider = $2 AND p2.finish = $3 AND p2.price_type = $4) ORDER BY p.price ASC LIMIT 1";
+    const rows = await this._conn.execute(sql, [
+      name,
+      provider,
+      finish,
+      priceType
+    ]);
+    return rows[0] ?? null;
+  }
+  async cheapestPrintings(options) {
+    await this._ensure();
+    await this._conn.ensureViews("cards");
+    const provider = options?.provider ?? "tcgplayer";
+    const finish = options?.finish ?? "normal";
+    const priceType = options?.priceType ?? "retail";
+    const limit = options?.limit ?? 100;
+    const offset = options?.offset ?? 0;
+    const sql = `SELECT c.name,   arg_min(c.setCode, p.price) AS cheapest_set,   arg_min(c.number, p.price) AS cheapest_number,   arg_min(c.uuid, p.price) AS cheapest_uuid,   MIN(p.price) AS min_price FROM cards c JOIN all_prices_today p ON c.uuid = p.uuid WHERE p.provider = $1 AND p.finish = $2 AND p.price_type = $3 AND p.date = (SELECT MAX(date) FROM all_prices_today) GROUP BY c.name ORDER BY min_price ASC LIMIT ${limit} OFFSET ${offset}`;
+    return this._conn.execute(sql, [provider, finish, priceType]);
+  }
+  async mostExpensivePrintings(options) {
+    await this._ensure();
+    await this._conn.ensureViews("cards");
+    const provider = options?.provider ?? "tcgplayer";
+    const finish = options?.finish ?? "normal";
+    const priceType = options?.priceType ?? "retail";
+    const limit = options?.limit ?? 100;
+    const offset = options?.offset ?? 0;
+    const sql = `SELECT c.name,   arg_max(c.setCode, p.price) AS priciest_set,   arg_max(c.number, p.price) AS priciest_number,   arg_max(c.uuid, p.price) AS priciest_uuid,   MAX(p.price) AS max_price FROM cards c JOIN all_prices_today p ON c.uuid = p.uuid WHERE p.provider = $1 AND p.finish = $2 AND p.price_type = $3 AND p.date = (SELECT MAX(date) FROM all_prices_today) GROUP BY c.name ORDER BY max_price DESC LIMIT ${limit} OFFSET ${offset}`;
+    return this._conn.execute(sql, [provider, finish, priceType]);
+  }
+};
+
+// src/queries/legalities.ts
+var LegalityQuery = class {
+  _conn;
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async _ensure() {
+    await this._conn.ensureViews("card_legalities");
+  }
+  async _cardsByStatus(formatName, status, options) {
+    await this._ensure();
+    await this._conn.ensureViews("cards");
+    const limit = options?.limit ?? 100;
+    const offset = options?.offset ?? 0;
+    return this._conn.execute(
+      `SELECT c.name, c.uuid FROM cards c JOIN card_legalities cl ON c.uuid = cl.uuid WHERE cl.format = $1 AND cl.status = $2 ORDER BY c.name ASC LIMIT ${limit} OFFSET ${offset}`,
+      [formatName, status]
+    );
+  }
+  async formatsForCard(uuid) {
+    await this._ensure();
+    const rows = await this._conn.execute(
+      "SELECT format, status FROM card_legalities WHERE uuid = $1",
+      [uuid]
+    );
+    const result = {};
+    for (const r of rows) {
+      result[r.format] = r.status;
+    }
+    return result;
+  }
+  async legalIn(formatName, options) {
+    await this._conn.ensureViews("cards", "card_legalities");
+    const limit = options?.limit ?? 100;
+    const offset = options?.offset ?? 0;
+    const sql = `SELECT DISTINCT c.* FROM cards c JOIN card_legalities cl ON c.uuid = cl.uuid WHERE cl.format = $1 AND cl.status = 'Legal' ORDER BY c.name ASC LIMIT ${limit} OFFSET ${offset}`;
+    return await this._conn.execute(sql, [formatName]);
+  }
+  async isLegal(uuid, formatName) {
+    await this._ensure();
+    const result = await this._conn.executeScalar(
+      "SELECT COUNT(*) FROM card_legalities WHERE uuid = $1 AND format = $2 AND status = 'Legal'",
+      [uuid, formatName]
+    );
+    return (result ?? 0) > 0;
+  }
+  async bannedIn(formatName, options) {
+    return this._cardsByStatus(formatName, "Banned", options);
+  }
+  async restrictedIn(formatName, options) {
+    return this._cardsByStatus(formatName, "Restricted", options);
+  }
+  async suspendedIn(formatName, options) {
+    return this._cardsByStatus(formatName, "Suspended", options);
+  }
+  async notLegalIn(formatName, options) {
+    return this._cardsByStatus(formatName, "Not Legal", options);
+  }
+};
+
+// src/queries/identifiers.ts
+var KNOWN_ID_COLUMNS = /* @__PURE__ */ new Set([
+  "cardKingdomEtchedId",
+  "cardKingdomFoilId",
+  "cardKingdomId",
+  "cardsphereId",
+  "cardsphereFoilId",
+  "mcmId",
+  "mcmMetaId",
+  "mtgArenaId",
+  "mtgoFoilId",
+  "mtgoId",
+  "multiverseId",
+  "scryfallId",
+  "scryfallIllustrationId",
+  "scryfallOracleId",
+  "tcgplayerEtchedProductId",
+  "tcgplayerProductId"
+]);
+var IdentifierQuery = class {
+  _conn;
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async _ensure() {
+    await this._conn.ensureViews("cards", "card_identifiers");
+  }
+  async _findBy(idColumn, value) {
+    await this._ensure();
+    const sql = `SELECT c.* FROM cards c JOIN card_identifiers ci ON c.uuid = ci.uuid WHERE ci.${idColumn} = $1`;
+    return await this._conn.execute(sql, [value]);
+  }
+  async findBy(idType, value) {
+    if (!KNOWN_ID_COLUMNS.has(idType)) {
+      throw new Error(
+        `Unknown identifier type '${idType}'. Known types: ${[...KNOWN_ID_COLUMNS].sort().join(", ")}`
+      );
+    }
+    return this._findBy(idType, value);
+  }
+  async findByScryfallId(scryfallId) {
+    return this._findBy("scryfallId", scryfallId);
+  }
+  async findByScryfallOracleId(oracleId) {
+    return this._findBy("scryfallOracleId", oracleId);
+  }
+  async findByScryfallIllustrationId(illustrationId) {
+    return this._findBy("scryfallIllustrationId", illustrationId);
+  }
+  async findByTcgplayerId(tcgplayerId) {
+    return this._findBy("tcgplayerProductId", tcgplayerId);
+  }
+  async findByTcgplayerEtchedId(tcgplayerEtchedId) {
+    return this._findBy("tcgplayerEtchedProductId", tcgplayerEtchedId);
+  }
+  async findByMtgoId(mtgoId) {
+    return this._findBy("mtgoId", mtgoId);
+  }
+  async findByMtgoFoilId(mtgoFoilId) {
+    return this._findBy("mtgoFoilId", mtgoFoilId);
+  }
+  async findByMtgArenaId(arenaId) {
+    return this._findBy("mtgArenaId", arenaId);
+  }
+  async findByMultiverseId(multiverseId) {
+    return this._findBy("multiverseId", multiverseId);
+  }
+  async findByMcmId(mcmId) {
+    return this._findBy("mcmId", mcmId);
+  }
+  async findByMcmMetaId(mcmMetaId) {
+    return this._findBy("mcmMetaId", mcmMetaId);
+  }
+  async findByCardKingdomId(ckId) {
+    return this._findBy("cardKingdomId", ckId);
+  }
+  async findByCardKingdomFoilId(ckFoilId) {
+    return this._findBy("cardKingdomFoilId", ckFoilId);
+  }
+  async findByCardKingdomEtchedId(ckEtchedId) {
+    return this._findBy("cardKingdomEtchedId", ckEtchedId);
+  }
+  async findByCardsphereId(csId) {
+    return this._findBy("cardsphereId", csId);
+  }
+  async findByCardsphereFoilId(csFoilId) {
+    return this._findBy("cardsphereFoilId", csFoilId);
+  }
+  async getIdentifiers(uuid) {
+    await this._conn.ensureViews("card_identifiers");
+    const rows = await this._conn.execute(
+      "SELECT * FROM card_identifiers WHERE uuid = $1",
+      [uuid]
+    );
+    return rows[0] ?? null;
+  }
+};
+
+// src/queries/decks.ts
+var DeckQuery = class {
+  _cache;
+  _data = null;
+  constructor(cache) {
+    this._cache = cache;
+  }
+  async _ensure() {
+    if (this._data !== null) return;
+    try {
+      const raw = await this._cache.loadJson("deck_list");
+      this._data = raw.data ?? [];
+    } catch {
+      this._data = [];
+    }
+  }
+  async list(options) {
+    await this._ensure();
+    let results = this._data;
+    if (options?.setCode) {
+      const codeUpper = options.setCode.toUpperCase();
+      results = results.filter(
+        (d) => (d.code ?? "").toUpperCase() === codeUpper
+      );
+    }
+    if (options?.deckType) {
+      results = results.filter((d) => d.type === options.deckType);
+    }
+    return results;
+  }
+  async search(options) {
+    await this._ensure();
+    let results = this._data;
+    if (options?.name) {
+      const nameLower = options.name.toLowerCase();
+      results = results.filter(
+        (d) => (d.name ?? "").toLowerCase().includes(nameLower)
+      );
+    }
+    if (options?.setCode) {
+      const codeUpper = options.setCode.toUpperCase();
+      results = results.filter(
+        (d) => (d.code ?? "").toUpperCase() === codeUpper
+      );
+    }
+    return results;
+  }
+  async count() {
+    await this._ensure();
+    return this._data.length;
+  }
+};
+
+// src/queries/sealed.ts
+var SealedQuery = class {
+  _conn;
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async _ensure() {
+    await this._conn.ensureViews("sets");
+  }
+  async list(options) {
+    await this._ensure();
+    try {
+      const q = new SQLBuilder("sets");
+      q.select("code", "name AS setName", "sealedProduct");
+      if (options?.setCode) {
+        q.whereEq("code", options.setCode.toUpperCase());
+      }
+      q.limit(options?.limit ?? 100);
+      const [sql, params] = q.build();
+      const rows = await this._conn.execute(sql, params);
+      const products = [];
+      for (const row of rows) {
+        const sealed = row.sealedProduct;
+        if (sealed && Array.isArray(sealed)) {
+          for (const sp of sealed) {
+            if (sp && typeof sp === "object") {
+              const product = sp;
+              if (options?.category && product.category !== options.category) {
+                continue;
+              }
+              product.setCode = row.code;
+              products.push(product);
+            }
+          }
+        }
+      }
+      return products;
+    } catch {
+      return [];
+    }
+  }
+  async get(uuid) {
+    await this._ensure();
+    try {
+      const sql = "SELECT sub.code AS setCode, sub.sp FROM (  SELECT code, UNNEST(sealedProduct) AS sp   FROM sets WHERE sealedProduct IS NOT NULL) sub WHERE sub.sp.uuid = $1 LIMIT 1";
+      const rows = await this._conn.execute(sql, [uuid]);
+      if (rows.length === 0) return null;
+      const row = rows[0];
+      const product = row.sp ?? {};
+      if (typeof product === "object") {
+        product.setCode = row.setCode;
+        return product;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/queries/skus.ts
+var SkuQuery = class {
+  _conn;
+  constructor(conn) {
+    this._conn = conn;
+  }
+  async _ensure() {
+    await this._conn.ensureViews("tcgplayer_skus");
+  }
+  async get(uuid) {
+    await this._ensure();
+    const rows = await this._conn.execute(
+      "SELECT * FROM tcgplayer_skus WHERE uuid = $1",
+      [uuid]
+    );
+    return rows;
+  }
+  async findBySkuId(skuId) {
+    await this._ensure();
+    const rows = await this._conn.execute(
+      "SELECT * FROM tcgplayer_skus WHERE skuId = $1",
+      [skuId]
+    );
+    return rows[0] ?? null;
+  }
+  async findByProductId(productId) {
+    await this._ensure();
+    return this._conn.execute(
+      "SELECT * FROM tcgplayer_skus WHERE productId = $1",
+      [productId]
+    );
+  }
+};
+
+// src/queries/enums.ts
+var EnumQuery = class {
+  _cache;
+  constructor(cache) {
+    this._cache = cache;
+  }
+  async keywords() {
+    const raw = await this._cache.loadJson("keywords");
+    return raw.data ?? {};
+  }
+  async cardTypes() {
+    const raw = await this._cache.loadJson("card_types");
+    return raw.data ?? {};
+  }
+  async enumValues() {
+    const raw = await this._cache.loadJson("enum_values");
+    return raw.data ?? {};
+  }
+};
+
+// src/client.ts
+var MtgjsonSDK = class _MtgjsonSDK {
+  _cache;
+  _conn;
+  _cards = null;
+  _sets = null;
+  _prices = null;
+  _decks = null;
+  _sealed = null;
+  _skus = null;
+  _identifiers = null;
+  _legalities = null;
+  _tokens = null;
+  _enums = null;
+  _booster = null;
+  constructor(options) {
+    this._cache = new CacheManager({
+      cacheDir: options?.cacheDir,
+      offline: options?.offline,
+      timeout: options?.timeout,
+      onProgress: options?.onProgress
+    });
+  }
+  static async create(options) {
+    const sdk = new _MtgjsonSDK(options);
+    await sdk._cache.init();
+    sdk._conn = await Connection.create(sdk._cache);
+    return sdk;
+  }
+  get cards() {
+    if (!this._cards) this._cards = new CardQuery(this._conn);
+    return this._cards;
+  }
+  get sets() {
+    if (!this._sets) this._sets = new SetQuery(this._conn);
+    return this._sets;
+  }
+  get prices() {
+    if (!this._prices) this._prices = new PriceQuery(this._conn);
+    return this._prices;
+  }
+  get decks() {
+    if (!this._decks) this._decks = new DeckQuery(this._cache);
+    return this._decks;
+  }
+  get sealed() {
+    if (!this._sealed) this._sealed = new SealedQuery(this._conn);
+    return this._sealed;
+  }
+  get skus() {
+    if (!this._skus) this._skus = new SkuQuery(this._conn);
+    return this._skus;
+  }
+  get identifiers() {
+    if (!this._identifiers) this._identifiers = new IdentifierQuery(this._conn);
+    return this._identifiers;
+  }
+  get legalities() {
+    if (!this._legalities) this._legalities = new LegalityQuery(this._conn);
+    return this._legalities;
+  }
+  get tokens() {
+    if (!this._tokens) this._tokens = new TokenQuery(this._conn);
+    return this._tokens;
+  }
+  get enums() {
+    if (!this._enums) this._enums = new EnumQuery(this._cache);
+    return this._enums;
+  }
+  get booster() {
+    if (!this._booster) this._booster = new BoosterSimulator(this._conn);
+    return this._booster;
+  }
+  get meta() {
+    return this._cache.loadJson("meta").catch(() => ({}));
+  }
+  get views() {
+    return [...this._conn._registeredViews].sort();
+  }
+  async sql(query, params) {
+    return this._conn.execute(query, params);
+  }
+  async refresh() {
+    if (!await this._cache.isStale()) return false;
+    this._conn._registeredViews.clear();
+    this._cards = null;
+    this._sets = null;
+    this._prices = null;
+    this._decks = null;
+    this._sealed = null;
+    this._skus = null;
+    this._identifiers = null;
+    this._legalities = null;
+    this._tokens = null;
+    this._enums = null;
+    this._booster = null;
+    return true;
+  }
+  async exportDb(path) {
+    const pathStr = path.replace(/\\/g, "/");
+    const raw = this._conn.raw;
+    await raw.run(`ATTACH '${pathStr}' AS export_db`);
+    try {
+      for (const viewName of [...this._conn._registeredViews].sort()) {
+        await raw.run(
+          `CREATE TABLE export_db.${viewName} AS SELECT * FROM ${viewName}`
+        );
+      }
+    } finally {
+      await raw.run("DETACH export_db");
+    }
+    return path;
+  }
+  async close() {
+    await this._conn.close();
+    this._cache.close();
+  }
+  /** For `await using sdk = await MtgjsonSDK.create()` */
+  async [Symbol.asyncDispose]() {
+    await this.close();
+  }
+};
+export {
+  BoosterSimulator,
+  CacheManager,
+  CardQuery,
+  Connection,
+  DeckQuery,
+  EnumQuery,
+  IdentifierQuery,
+  LegalityQuery,
+  MtgjsonSDK,
+  PriceQuery,
+  SQLBuilder,
+  SealedQuery,
+  SetQuery,
+  SkuQuery,
+  TokenQuery
+};
+//# sourceMappingURL=index.js.map