@newcms/database 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,9 +1,1529 @@
-export { createConnection } from './connection.js';
-export * from './schema/index.js';
-export { ObjectCache } from './cache/index.js';
-export { OptionsRepository } from './repositories/options-repository.js';
-export { PostRepository } from './repositories/post-repository.js';
-export { MetaRepository } from './repositories/meta-repository.js';
-export { TaxonomyRepository } from './repositories/taxonomy-repository.js';
-export { RevisionRepository } from './repositories/revision-repository.js';
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/connection.ts
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+// src/schema/index.ts
+var schema_exports = {};
+__export(schema_exports, {
+  commentmeta: () => commentmeta,
+  comments: () => comments,
+  links: () => links,
+  options: () => options,
+  postmeta: () => postmeta,
+  posts: () => posts,
+  scheduledEvents: () => scheduledEvents,
+  sessions: () => sessions,
+  termRelationships: () => termRelationships,
+  termTaxonomy: () => termTaxonomy,
+  termmeta: () => termmeta,
+  terms: () => terms,
+  usermeta: () => usermeta,
+  users: () => users
+});
+
+// src/schema/posts.ts
+import {
+  pgTable as pgTable2,
+  serial as serial2,
+  bigint,
+  text as text2,
+  timestamp as timestamp2,
+  varchar as varchar2,
+  index as index2,
+  jsonb as jsonb2
+} from "drizzle-orm/pg-core";
+
+// src/schema/users.ts
+import {
+  pgTable,
+  serial,
+  text,
+  timestamp,
+  varchar,
+  index,
+  jsonb
+} from "drizzle-orm/pg-core";
+var users = pgTable(
+  "users",
+  {
+    id: serial("id").primaryKey(),
+    userLogin: varchar("user_login", { length: 60 }).notNull().unique(),
+    userPass: varchar("user_pass", { length: 255 }).notNull().default(""),
+    userNicename: varchar("user_nicename", { length: 50 }).notNull().default(""),
+    userEmail: varchar("user_email", { length: 100 }).notNull().unique(),
+    userUrl: varchar("user_url", { length: 100 }).notNull().default(""),
+    userRegistered: timestamp("user_registered", { withTimezone: true }).notNull().defaultNow(),
+    userActivationKey: varchar("user_activation_key", { length: 255 }).notNull().default(""),
+    userStatus: varchar("user_status", { length: 20 }).notNull().default("active"),
+    displayName: varchar("display_name", { length: 250 }).notNull().default("")
+  },
+  (table) => [
+    index("idx_user_login").on(table.userLogin),
+    index("idx_user_nicename").on(table.userNicename),
+    index("idx_user_email").on(table.userEmail)
+  ]
+);
+var usermeta = pgTable(
+  "usermeta",
+  {
+    umetaId: serial("umeta_id").primaryKey(),
+    userId: serial("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    metaKey: varchar("meta_key", { length: 255 }),
+    metaValue: text("meta_value"),
+    metaValueJson: jsonb("meta_value_json")
+  },
+  (table) => [
+    index("idx_usermeta_user_id").on(table.userId),
+    index("idx_usermeta_meta_key").on(table.metaKey)
+  ]
+);
+
+// src/schema/posts.ts
+var posts = pgTable2(
+  "posts",
+  {
+    id: serial2("id").primaryKey(),
+    postAuthor: bigint("post_author", { mode: "number" }).notNull().default(0).references(() => users.id),
+    postDate: timestamp2("post_date", { withTimezone: true }).notNull().defaultNow(),
+    postDateGmt: timestamp2("post_date_gmt", { withTimezone: true }).notNull().defaultNow(),
+    postContent: text2("post_content").notNull().default(""),
+    postTitle: text2("post_title").notNull().default(""),
+    postExcerpt: text2("post_excerpt").notNull().default(""),
+    postStatus: varchar2("post_status", { length: 20 }).notNull().default("publish"),
+    commentStatus: varchar2("comment_status", { length: 20 }).notNull().default("open"),
+    pingStatus: varchar2("ping_status", { length: 20 }).notNull().default("open"),
+    postPassword: varchar2("post_password", { length: 255 }).notNull().default(""),
+    postName: varchar2("post_name", { length: 200 }).notNull().default(""),
+    toPing: text2("to_ping").notNull().default(""),
+    pinged: text2("pinged").notNull().default(""),
+    postModified: timestamp2("post_modified", { withTimezone: true }).notNull().defaultNow(),
+    postModifiedGmt: timestamp2("post_modified_gmt", { withTimezone: true }).notNull().defaultNow(),
+    postContentFiltered: text2("post_content_filtered").notNull().default(""),
+    postParent: bigint("post_parent", { mode: "number" }).notNull().default(0),
+    guid: varchar2("guid", { length: 255 }).notNull().default(""),
+    menuOrder: bigint("menu_order", { mode: "number" }).notNull().default(0),
+    postType: varchar2("post_type", { length: 20 }).notNull().default("post"),
+    postMimeType: varchar2("post_mime_type", { length: 100 }).notNull().default(""),
+    commentCount: bigint("comment_count", { mode: "number" }).notNull().default(0)
+  },
+  (table) => [
+    index2("idx_post_name").on(table.postName),
+    index2("idx_post_type_status_date").on(table.postType, table.postStatus, table.postDate),
+    index2("idx_post_parent").on(table.postParent),
+    index2("idx_post_author").on(table.postAuthor)
+  ]
+);
+var postmeta = pgTable2(
+  "postmeta",
+  {
+    metaId: serial2("meta_id").primaryKey(),
+    postId: bigint("post_id", { mode: "number" }).notNull().references(() => posts.id, { onDelete: "cascade" }),
+    metaKey: varchar2("meta_key", { length: 255 }),
+    metaValue: text2("meta_value"),
+    metaValueJson: jsonb2("meta_value_json")
+  },
+  (table) => [
+    index2("idx_postmeta_post_id").on(table.postId),
+    index2("idx_postmeta_meta_key").on(table.metaKey),
+    index2("idx_postmeta_post_key").on(table.postId, table.metaKey)
+  ]
+);
+
+// src/schema/comments.ts
+import {
+  pgTable as pgTable3,
+  serial as serial3,
+  bigint as bigint2,
+  text as text3,
+  timestamp as timestamp3,
+  varchar as varchar3,
+  index as index3,
+  jsonb as jsonb3
+} from "drizzle-orm/pg-core";
+var comments = pgTable3(
+  "comments",
+  {
+    commentId: serial3("comment_id").primaryKey(),
+    commentPostId: bigint2("comment_post_id", { mode: "number" }).notNull().default(0).references(() => posts.id, { onDelete: "cascade" }),
+    commentAuthor: text3("comment_author").notNull().default(""),
+    commentAuthorEmail: varchar3("comment_author_email", { length: 100 }).notNull().default(""),
+    commentAuthorUrl: varchar3("comment_author_url", { length: 200 }).notNull().default(""),
+    commentAuthorIp: varchar3("comment_author_ip", { length: 100 }).notNull().default(""),
+    commentDate: timestamp3("comment_date", { withTimezone: true }).notNull().defaultNow(),
+    commentDateGmt: timestamp3("comment_date_gmt", { withTimezone: true }).notNull().defaultNow(),
+    commentContent: text3("comment_content").notNull().default(""),
+    commentKarma: bigint2("comment_karma", { mode: "number" }).notNull().default(0),
+    commentApproved: varchar3("comment_approved", { length: 20 }).notNull().default("1"),
+    commentAgent: varchar3("comment_agent", { length: 255 }).notNull().default(""),
+    commentType: varchar3("comment_type", { length: 20 }).notNull().default("comment"),
+    commentParent: bigint2("comment_parent", { mode: "number" }).notNull().default(0),
+    userId: bigint2("user_id", { mode: "number" }).notNull().default(0).references(() => users.id)
+  },
+  (table) => [
+    index3("idx_comment_post_id").on(table.commentPostId),
+    index3("idx_comment_approved_date_gmt").on(table.commentApproved, table.commentDateGmt),
+    index3("idx_comment_date_gmt").on(table.commentDateGmt),
+    index3("idx_comment_parent").on(table.commentParent),
+    index3("idx_comment_author_email").on(table.commentAuthorEmail)
+  ]
+);
+var commentmeta = pgTable3(
+  "commentmeta",
+  {
+    metaId: serial3("meta_id").primaryKey(),
+    commentId: bigint2("comment_id", { mode: "number" }).notNull().references(() => comments.commentId, { onDelete: "cascade" }),
+    metaKey: varchar3("meta_key", { length: 255 }),
+    metaValue: text3("meta_value"),
+    metaValueJson: jsonb3("meta_value_json")
+  },
+  (table) => [
+    index3("idx_commentmeta_comment_id").on(table.commentId),
+    index3("idx_commentmeta_meta_key").on(table.metaKey)
+  ]
+);
+
+// src/schema/terms.ts
+import {
+  pgTable as pgTable4,
+  serial as serial4,
+  bigint as bigint3,
+  text as text4,
+  varchar as varchar4,
+  index as index4,
+  jsonb as jsonb4,
+  uniqueIndex,
+  primaryKey
+} from "drizzle-orm/pg-core";
+var terms = pgTable4(
+  "terms",
+  {
+    termId: serial4("term_id").primaryKey(),
+    name: varchar4("name", { length: 200 }).notNull().default(""),
+    slug: varchar4("slug", { length: 200 }).notNull().default(""),
+    termGroup: bigint3("term_group", { mode: "number" }).notNull().default(0)
+  },
+  (table) => [index4("idx_term_slug").on(table.slug), index4("idx_term_name").on(table.name)]
+);
+var termTaxonomy = pgTable4(
+  "term_taxonomy",
+  {
+    termTaxonomyId: serial4("term_taxonomy_id").primaryKey(),
+    termId: bigint3("term_id", { mode: "number" }).notNull().references(() => terms.termId, { onDelete: "cascade" }),
+    taxonomy: varchar4("taxonomy", { length: 32 }).notNull().default(""),
+    description: text4("description").notNull().default(""),
+    parent: bigint3("parent", { mode: "number" }).notNull().default(0),
+    count: bigint3("count", { mode: "number" }).notNull().default(0)
+  },
+  (table) => [
+    uniqueIndex("idx_term_id_taxonomy").on(table.termId, table.taxonomy),
+    index4("idx_taxonomy").on(table.taxonomy)
+  ]
+);
+var termRelationships = pgTable4(
+  "term_relationships",
+  {
+    objectId: bigint3("object_id", { mode: "number" }).notNull().references(() => posts.id, { onDelete: "cascade" }),
+    termTaxonomyId: bigint3("term_taxonomy_id", { mode: "number" }).notNull().references(() => termTaxonomy.termTaxonomyId, { onDelete: "cascade" }),
+    termOrder: bigint3("term_order", { mode: "number" }).notNull().default(0)
+  },
+  (table) => [
+    primaryKey({ columns: [table.objectId, table.termTaxonomyId] }),
+    index4("idx_term_taxonomy_id").on(table.termTaxonomyId)
+  ]
+);
+var termmeta = pgTable4(
+  "termmeta",
+  {
+    metaId: serial4("meta_id").primaryKey(),
+    termId: bigint3("term_id", { mode: "number" }).notNull().references(() => terms.termId, { onDelete: "cascade" }),
+    metaKey: varchar4("meta_key", { length: 255 }),
+    metaValue: text4("meta_value"),
+    metaValueJson: jsonb4("meta_value_json")
+  },
+  (table) => [
+    index4("idx_termmeta_term_id").on(table.termId),
+    index4("idx_termmeta_meta_key").on(table.metaKey)
+  ]
+);
+
+// src/schema/options.ts
+import {
+  pgTable as pgTable5,
+  serial as serial5,
+  text as text5,
+  varchar as varchar5,
+  boolean,
+  jsonb as jsonb5,
+  uniqueIndex as uniqueIndex2,
+  index as index5
+} from "drizzle-orm/pg-core";
+var options = pgTable5(
+  "options",
+  {
+    optionId: serial5("option_id").primaryKey(),
+    optionName: varchar5("option_name", { length: 191 }).notNull().unique(),
+    optionValue: text5("option_value").notNull().default(""),
+    optionValueJson: jsonb5("option_value_json"),
+    autoload: boolean("autoload").notNull().default(true)
+  },
+  (table) => [
+    uniqueIndex2("idx_option_name").on(table.optionName),
+    index5("idx_autoload").on(table.autoload)
+  ]
+);
+
+// src/schema/links.ts
+import {
+  pgTable as pgTable6,
+  serial as serial6,
+  text as text6,
+  timestamp as timestamp4,
+  varchar as varchar6,
+  bigint as bigint4,
+  index as index6
+} from "drizzle-orm/pg-core";
+var links = pgTable6(
+  "links",
+  {
+    linkId: serial6("link_id").primaryKey(),
+    linkUrl: varchar6("link_url", { length: 255 }).notNull().default(""),
+    linkName: varchar6("link_name", { length: 255 }).notNull().default(""),
+    linkImage: varchar6("link_image", { length: 255 }).notNull().default(""),
+    linkTarget: varchar6("link_target", { length: 25 }).notNull().default(""),
+    linkDescription: varchar6("link_description", { length: 255 }).notNull().default(""),
+    linkVisible: varchar6("link_visible", { length: 20 }).notNull().default("Y"),
+    linkOwner: bigint4("link_owner", { mode: "number" }).notNull().default(1),
+    linkRating: bigint4("link_rating", { mode: "number" }).notNull().default(0),
+    linkUpdated: timestamp4("link_updated", { withTimezone: true }).notNull().defaultNow(),
+    linkRel: varchar6("link_rel", { length: 255 }).notNull().default(""),
+    linkNotes: text6("link_notes").notNull().default(""),
+    linkRss: varchar6("link_rss", { length: 255 }).notNull().default("")
+  },
+  (table) => [index6("idx_link_visible").on(table.linkVisible)]
+);
+
+// src/schema/sessions.ts
+import { pgTable as pgTable7, serial as serial7, bigint as bigint5, varchar as varchar7, timestamp as timestamp5, jsonb as jsonb6, index as index7 } from "drizzle-orm/pg-core";
+var sessions = pgTable7(
+  "sessions",
+  {
+    id: serial7("id").primaryKey(),
+    userId: bigint5("user_id", { mode: "number" }).notNull().references(() => users.id, { onDelete: "cascade" }),
+    tokenHash: varchar7("token_hash", { length: 255 }).notNull().unique(),
+    createdAt: timestamp5("created_at", { withTimezone: true }).notNull().defaultNow(),
+    expiresAt: timestamp5("expires_at", { withTimezone: true }).notNull(),
+    ip: varchar7("ip", { length: 45 }).notNull().default(""),
+    userAgent: varchar7("user_agent", { length: 500 }).notNull().default(""),
+    data: jsonb6("data")
+  },
+  (table) => [
+    index7("idx_session_user_id").on(table.userId),
+    index7("idx_session_token_hash").on(table.tokenHash),
+    index7("idx_session_expires_at").on(table.expiresAt)
+  ]
+);
+
+// src/schema/scheduled-events.ts
+import { pgTable as pgTable8, serial as serial8, varchar as varchar8, timestamp as timestamp6, jsonb as jsonb7, bigint as bigint6, index as index8 } from "drizzle-orm/pg-core";
+var scheduledEvents = pgTable8(
+  "scheduled_events",
+  {
+    id: serial8("id").primaryKey(),
+    hook: varchar8("hook", { length: 255 }).notNull(),
+    args: jsonb7("args").notNull().default("[]"),
+    schedule: varchar8("schedule", { length: 50 }),
+    intervalSeconds: bigint6("interval_seconds", { mode: "number" }),
+    nextRunAt: timestamp6("next_run_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp6("created_at", { withTimezone: true }).notNull().defaultNow(),
+    status: varchar8("status", { length: 20 }).notNull().default("pending")
+  },
+  (table) => [
+    index8("idx_scheduled_hook").on(table.hook),
+    index8("idx_scheduled_next_run").on(table.nextRunAt),
+    index8("idx_scheduled_status").on(table.status)
+  ]
+);
+
+// src/connection.ts
+function getConfigFromEnv() {
+  const password = process.env["DB_PASSWORD"];
+  if (!password) {
+    throw new Error(
+      "DB_PASSWORD environment variable is required. Set it in your .env file or environment."
+    );
+  }
+  return {
+    host: process.env["DB_HOST"] ?? "localhost",
+    port: parseInt(process.env["DB_PORT"] ?? "5432", 10),
+    database: process.env["DB_NAME"] ?? "newcms",
+    user: process.env["DB_USER"] ?? "newcms",
+    password,
+    maxConnections: parseInt(process.env["DB_MAX_CONNECTIONS"] ?? "10", 10)
+  };
+}
+function createConnection(config) {
+  const cfg = config ?? getConfigFromEnv();
+  const client = postgres({
+    host: cfg.host,
+    port: cfg.port,
+    database: cfg.database,
+    user: cfg.user,
+    password: cfg.password,
+    max: cfg.maxConnections ?? 10
+  });
+  const db = drizzle(client, { schema: schema_exports });
+  return { db, client };
+}
+
+// src/cache/object-cache.ts
+import Redis from "ioredis";
+var ObjectCache = class {
+  redis;
+  siteId = 1;
+  keyPrefix;
+  defaultTtl;
+  /** Groups that are shared across all sites (multisite) */
+  globalGroups = /* @__PURE__ */ new Set();
+  /** Per-group TTL overrides (in seconds) */
+  groupTtl = /* @__PURE__ */ new Map();
+  /** Local in-memory cache for the current request (non-persistent) */
+  localCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.redis = new Redis({
+      host: config.host,
+      port: config.port,
+      lazyConnect: true,
+      maxRetriesPerRequest: 3
+    });
+    this.keyPrefix = config.keyPrefix ?? "cache";
+    this.defaultTtl = config.defaultTtl ?? 0;
+  }
+  async connect() {
+    await this.redis.connect();
+  }
+  async disconnect() {
+    await this.redis.quit();
+  }
+  /**
+   * Set the current site ID (for multisite per-site cache isolation).
+   */
+  setSiteId(siteId) {
+    this.siteId = siteId;
+  }
+  /**
+   * Register groups as global (shared across sites in multisite).
+   */
+  addGlobalGroups(groups) {
+    for (const group of groups) {
+      this.globalGroups.add(group);
+    }
+  }
+  /**
+   * Set TTL for a specific cache group.
+   */
+  setGroupTtl(group, ttlSeconds) {
+    this.groupTtl.set(group, ttlSeconds);
+  }
+  /**
+   * Build the Redis key for a cache entry.
+   */
+  buildKey(key, group = "default") {
+    if (this.globalGroups.has(group)) {
+      return `${this.keyPrefix}:global:${group}:${key}`;
+    }
+    return `${this.keyPrefix}:site:${this.siteId}:${group}:${key}`;
+  }
+  /**
+   * Build a local cache key (in-memory, for current request).
+   */
+  buildLocalKey(key, group = "default") {
+    if (this.globalGroups.has(group)) {
+      return `global:${group}:${key}`;
+    }
+    return `site:${this.siteId}:${group}:${key}`;
+  }
+  /**
+   * Get TTL for a group in seconds.
+   */
+  getTtl(group) {
+    return this.groupTtl.get(group) ?? this.defaultTtl;
+  }
+  /**
+   * Get a cached value.
+   *
+   * @returns The cached value, or undefined if not found
+   */
+  async get(key, group = "default") {
+    const localKey = this.buildLocalKey(key, group);
+    if (this.localCache.has(localKey)) {
+      return this.localCache.get(localKey);
+    }
+    const redisKey = this.buildKey(key, group);
+    const raw = await this.redis.get(redisKey);
+    if (raw === null) return void 0;
+    try {
+      const value = JSON.parse(raw);
+      this.localCache.set(localKey, value);
+      return value;
+    } catch {
+      return raw;
+    }
+  }
+  /**
+   * Set a cached value.
+   *
+   * @param key - Cache key
+   * @param value - Value to cache (will be JSON serialized)
+   * @param group - Cache group
+   * @param ttl - TTL in seconds (overrides group default). 0 = no expiry.
+   * @returns true on success
+   */
+  async set(key, value, group = "default", ttl) {
+    const redisKey = this.buildKey(key, group);
+    const serialized = JSON.stringify(value);
+    const effectiveTtl = ttl ?? this.getTtl(group);
+    if (effectiveTtl > 0) {
+      await this.redis.setex(redisKey, effectiveTtl, serialized);
+    } else {
+      await this.redis.set(redisKey, serialized);
+    }
+    const localKey = this.buildLocalKey(key, group);
+    this.localCache.set(localKey, value);
+    return true;
+  }
+  /**
+   * Add a cached value only if it doesn't already exist.
+   *
+   * @returns true if the value was added, false if key already exists
+   */
+  async add(key, value, group = "default", ttl) {
+    const redisKey = this.buildKey(key, group);
+    const serialized = JSON.stringify(value);
+    const effectiveTtl = ttl ?? this.getTtl(group);
+    let result;
+    if (effectiveTtl > 0) {
+      result = await this.redis.set(redisKey, serialized, "EX", effectiveTtl, "NX");
+    } else {
+      result = await this.redis.set(redisKey, serialized, "NX");
+    }
+    if (result === "OK") {
+      const localKey = this.buildLocalKey(key, group);
+      this.localCache.set(localKey, value);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Delete a cached value.
+   *
+   * @returns true if the key existed and was deleted
+   */
+  async delete(key, group = "default") {
+    const redisKey = this.buildKey(key, group);
+    const count = await this.redis.del(redisKey);
+    const localKey = this.buildLocalKey(key, group);
+    this.localCache.delete(localKey);
+    return count > 0;
+  }
+  /**
+   * Increment a numeric cached value.
+   *
+   * @returns The new value, or false if key doesn't exist
+   */
+  async incr(key, group = "default", offset = 1) {
+    const redisKey = this.buildKey(key, group);
+    const keyExists = await this.redis.exists(redisKey);
+    if (!keyExists) return false;
+    const current = await this.get(key, group);
+    if (current === void 0 || typeof current !== "number") return false;
+    const newValue = current + offset;
+    await this.set(key, newValue, group);
+    return newValue;
+  }
+  /**
+   * Decrement a numeric cached value.
+   *
+   * @returns The new value, or false if key doesn't exist
+   */
+  async decr(key, group = "default", offset = 1) {
+    return this.incr(key, group, -offset);
+  }
+  /**
+   * Get multiple cached values at once.
+   *
+   * @returns Map of key -> value (missing keys are not included)
+   */
+  async getMultiple(keys, group = "default") {
+    const result = /* @__PURE__ */ new Map();
+    if (keys.length === 0) return result;
+    const redisKeys = keys.map((k) => this.buildKey(k, group));
+    const values = await this.redis.mget(...redisKeys);
+    for (let i = 0; i < keys.length; i++) {
+      const raw = values[i];
+      if (raw !== null) {
+        try {
+          const value = JSON.parse(raw);
+          result.set(keys[i], value);
+          const localKey = this.buildLocalKey(keys[i], group);
+          this.localCache.set(localKey, value);
+        } catch {
+          result.set(keys[i], raw);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Set multiple cached values at once.
+   */
+  async setMultiple(entries, group = "default", ttl) {
+    const items = entries instanceof Map ? entries : new Map(Object.entries(entries));
+    if (items.size === 0) return true;
+    const effectiveTtl = ttl ?? this.getTtl(group);
+    const pipeline = this.redis.pipeline();
+    for (const [key, value] of items) {
+      const redisKey = this.buildKey(key, group);
+      const serialized = JSON.stringify(value);
+      if (effectiveTtl > 0) {
+        pipeline.setex(redisKey, effectiveTtl, serialized);
+      } else {
+        pipeline.set(redisKey, serialized);
+      }
+      const localKey = this.buildLocalKey(key, group);
+      this.localCache.set(localKey, value);
+    }
+    await pipeline.exec();
+    return true;
+  }
+  /**
+   * Flush all keys in a specific group using SCAN + pipeline DEL.
+   *
+   * @returns Number of keys deleted
+   */
+  async flushGroup(group) {
+    const pattern = this.globalGroups.has(group) ? `${this.keyPrefix}:global:${group}:*` : `${this.keyPrefix}:site:${this.siteId}:${group}:*`;
+    let deleted = 0;
+    let cursor = "0";
+    do {
+      const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+      cursor = nextCursor;
+      if (keys.length > 0) {
+        const pipeline = this.redis.pipeline();
+        for (const key of keys) {
+          pipeline.del(key);
+        }
+        await pipeline.exec();
+        deleted += keys.length;
+      }
+    } while (cursor !== "0");
+    for (const localKey of this.localCache.keys()) {
+      if (localKey.startsWith(`${group}:`)) {
+        this.localCache.delete(localKey);
+      }
+    }
+    return deleted;
+  }
+  /**
+   * Flush all cached data (all groups, all sites).
+   * Uses SCAN + DEL to only clear cache keys (not other Redis data).
+   *
+   * @returns Number of keys deleted
+   */
+  async flushAll() {
+    const pattern = `${this.keyPrefix}:*`;
+    let deleted = 0;
+    let cursor = "0";
+    do {
+      const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+      cursor = nextCursor;
+      if (keys.length > 0) {
+        const pipeline = this.redis.pipeline();
+        for (const key of keys) {
+          pipeline.del(key);
+        }
+        await pipeline.exec();
+        deleted += keys.length;
+      }
+    } while (cursor !== "0");
+    this.localCache.clear();
+    return deleted;
+  }
+  /**
+   * Clear only the local in-memory cache (for request boundary cleanup).
+   */
+  clearLocalCache() {
+    this.localCache.clear();
+  }
+  /**
+   * Check if a key exists in cache.
+   */
+  async exists(key, group = "default") {
+    const localKey = this.buildLocalKey(key, group);
+    if (this.localCache.has(localKey)) return true;
+    const redisKey = this.buildKey(key, group);
+    return await this.redis.exists(redisKey) === 1;
+  }
+  /**
+   * Get the underlying Redis instance (for advanced operations).
+   */
+  getRedis() {
+    return this.redis;
+  }
+};
+
+// src/repositories/options-repository.ts
+import { eq } from "drizzle-orm";
+var CACHE_GROUP = "options";
+var AUTOLOAD_CACHE_KEY = "__autoloaded";
+var NOT_FOUND_GROUP = "options_nf";
+var OptionsRepository = class {
+  constructor(db, cache) {
+    this.db = db;
+    this.cache = cache;
+  }
+  db;
+  cache;
+  /**
+   * Get an option value.
+   *
+   * Lookup order:
+   * 1. Redis cache (group "options")
+   * 2. "Not found" cache (avoids repeated DB queries for missing keys)
+   * 3. Database
+   */
+  async getOption(name, defaultValue) {
+    const cached = await this.cache.get(name, CACHE_GROUP);
+    if (cached !== void 0) return cached;
+    const isNotFound = await this.cache.get(name, NOT_FOUND_GROUP);
+    if (isNotFound !== void 0) return defaultValue;
+    const rows = await this.db.select().from(options).where(eq(options.optionName, name)).limit(1);
+    if (rows.length === 0) {
+      await this.cache.set(name, true, NOT_FOUND_GROUP, 3600);
+      return defaultValue;
+    }
+    const row = rows[0];
+    const value = this.deserializeValue(row);
+    await this.cache.set(name, value, CACHE_GROUP);
+    return value;
+  }
+  /**
+   * Add a new option. Fails if option already exists.
+   *
+   * @returns true if the option was created
+   */
+  async addOption(name, value, autoload = true) {
+    const existing = await this.db.select({ optionId: options.optionId }).from(options).where(eq(options.optionName, name)).limit(1);
+    if (existing.length > 0) return false;
+    const { textValue, jsonValue } = this.serializeValue(value);
+    await this.db.insert(options).values({
+      optionName: name,
+      optionValue: textValue,
+      optionValueJson: jsonValue,
+      autoload
+    });
+    await this.cache.set(name, value, CACHE_GROUP);
+    await this.cache.delete(name, NOT_FOUND_GROUP);
+    if (autoload) {
+      await this.cache.delete(AUTOLOAD_CACHE_KEY, CACHE_GROUP);
+    }
+    return true;
+  }
+  /**
+   * Update an existing option, or create it if it doesn't exist.
+   *
+   * @returns true if the value was changed
+   */
+  async updateOption(name, value, autoload) {
+    const { textValue, jsonValue } = this.serializeValue(value);
+    const existing = await this.db.select().from(options).where(eq(options.optionName, name)).limit(1);
+    if (existing.length === 0) {
+      return this.addOption(name, value, autoload ?? true);
+    }
+    const row = existing[0];
+    if (row.optionValue === textValue && autoload === void 0) {
+      return false;
+    }
+    const updateData = {
+      optionValue: textValue,
+      optionValueJson: jsonValue
+    };
+    if (autoload !== void 0) {
+      updateData["autoload"] = autoload;
+    }
+    await this.db.update(options).set(updateData).where(eq(options.optionName, name));
+    await this.cache.set(name, value, CACHE_GROUP);
+    await this.cache.delete(name, NOT_FOUND_GROUP);
+    await this.cache.delete(AUTOLOAD_CACHE_KEY, CACHE_GROUP);
+    return true;
+  }
+  /**
+   * Delete an option.
+   *
+   * @returns true if the option existed and was deleted
+   */
+  async deleteOption(name) {
+    const result = await this.db.delete(options).where(eq(options.optionName, name)).returning({ optionId: options.optionId });
+    if (result.length === 0) return false;
+    await this.cache.delete(name, CACHE_GROUP);
+    await this.cache.delete(name, NOT_FOUND_GROUP);
+    await this.cache.delete(AUTOLOAD_CACHE_KEY, CACHE_GROUP);
+    return true;
+  }
+  /**
+   * Load all autoloaded options into cache at once.
+   * Called during bootstrap to pre-warm the cache.
+   */
+  async loadAutoloadedOptions() {
+    const cached = await this.cache.get(
+      AUTOLOAD_CACHE_KEY,
+      CACHE_GROUP
+    );
+    if (cached) {
+      const result2 = new Map(Object.entries(cached));
+      for (const [key, value] of result2) {
+        await this.cache.set(key, value, CACHE_GROUP);
+      }
+      return result2;
+    }
+    const rows = await this.db.select().from(options).where(eq(options.autoload, true));
+    const result = /* @__PURE__ */ new Map();
+    const autoloadMap = {};
+    for (const row of rows) {
+      const value = this.deserializeValue(row);
+      result.set(row.optionName, value);
+      autoloadMap[row.optionName] = value;
+      await this.cache.set(row.optionName, value, CACHE_GROUP);
+    }
+    await this.cache.set(AUTOLOAD_CACHE_KEY, autoloadMap, CACHE_GROUP);
+    return result;
+  }
+  /**
+   * Serialize a value for storage.
+   * Complex types (objects, arrays) are stored in both text and JSONB columns.
+   */
+  serializeValue(value) {
+    if (value === null || value === void 0) {
+      return { textValue: "", jsonValue: null };
+    }
+    if (typeof value === "string") {
+      try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "object" && parsed !== null) {
+          return { textValue: value, jsonValue: parsed };
+        }
+      } catch {
+      }
+      return { textValue: value, jsonValue: null };
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return { textValue: String(value), jsonValue: null };
+    }
+    const textValue = JSON.stringify(value);
+    return { textValue, jsonValue: value };
+  }
+  /**
+   * Deserialize a value from the database row.
+   * Prefers JSONB column when available (already parsed).
+   */
+  deserializeValue(row) {
+    if (row.optionValueJson !== null && row.optionValueJson !== void 0) {
+      return row.optionValueJson;
+    }
+    try {
+      return JSON.parse(row.optionValue);
+    } catch {
+      return row.optionValue;
+    }
+  }
+};
+
+// src/repositories/post-repository.ts
+import { eq as eq3, and as and2, sql as sql2 } from "drizzle-orm";
+
+// src/repositories/meta-repository.ts
+import { eq as eq2, and, inArray, sql } from "drizzle-orm";
+var MetaRepository = class {
+  constructor(db, table, columns, colNames) {
+    this.db = db;
+    this.table = table;
+    this.columns = columns;
+    this.colNames = colNames;
+  }
+  db;
+  table;
+  columns;
+  colNames;
+  async get(objectId, key) {
+    const rows = await this.db.select().from(this.table).where(and(eq2(this.columns.objectId, objectId), eq2(this.columns.metaKey, key))).limit(1);
+    if (rows.length === 0) return void 0;
+    return this.deserialize(this.toMetaEntry(rows[0]));
+  }
+  async getAll(objectId, key) {
+    const rows = await this.db.select().from(this.table).where(and(eq2(this.columns.objectId, objectId), eq2(this.columns.metaKey, key)));
+    return rows.map((r) => this.deserialize(this.toMetaEntry(r)));
+  }
+  async getAllForObject(objectId) {
+    const rows = await this.db.select().from(this.table).where(eq2(this.columns.objectId, objectId));
+    const result = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const entry = this.toMetaEntry(row);
+      const key = entry.metaKey ?? "";
+      const values = result.get(key) ?? [];
+      values.push(this.deserialize(entry));
+      result.set(key, values);
+    }
+    return result;
+  }
+  async batchLoad(objectIds) {
+    if (objectIds.length === 0) return /* @__PURE__ */ new Map();
+    const rows = await this.db.select().from(this.table).where(inArray(this.columns.objectId, objectIds));
+    const result = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const rawRow = row;
+      const entry = this.toMetaEntry(rawRow);
+      if (!result.has(entry.objectId)) {
+        result.set(entry.objectId, /* @__PURE__ */ new Map());
+      }
+      const objectMeta = result.get(entry.objectId);
+      const key = entry.metaKey ?? "";
+      const values = objectMeta.get(key) ?? [];
+      values.push(this.deserialize(entry));
+      objectMeta.set(key, values);
+    }
+    return result;
+  }
+  async add(objectId, key, value) {
+    const { textValue, jsonValue } = this.serialize(value);
+    const jsonStr = jsonValue !== null ? JSON.stringify(jsonValue) : null;
+    const s = this.colNames.sql;
+    const t = this.colNames.table;
+    const rows = await this.db.execute(sql`
+			INSERT INTO ${sql.raw(`"${t}"`)} (${sql.raw(`"${s.objectId}"`)}, ${sql.raw(`"${s.metaKey}"`)}, ${sql.raw(`"${s.metaValue}"`)}, ${sql.raw(`"${s.metaValueJson}"`)})
+			VALUES (${objectId}, ${key}, ${textValue}, ${jsonStr}::jsonb)
+			RETURNING ${sql.raw(`"${s.metaId}"`)}
+		`);
+    const returnedRows = rows;
+    return returnedRows[0][s.metaId];
+  }
+  async update(objectId, key, value) {
+    const { textValue, jsonValue } = this.serialize(value);
+    const existing = await this.db.select({ metaId: this.columns.metaId }).from(this.table).where(and(eq2(this.columns.objectId, objectId), eq2(this.columns.metaKey, key))).limit(1);
+    if (existing.length === 0) {
+      await this.add(objectId, key, value);
+      return true;
+    }
+    const metaId = existing[0].metaId;
+    const jsonStr = jsonValue !== null ? JSON.stringify(jsonValue) : null;
+    const s = this.colNames.sql;
+    const t = this.colNames.table;
+    await this.db.execute(sql`
+			UPDATE ${sql.raw(`"${t}"`)}
+			SET ${sql.raw(`"${s.metaValue}"`)} = ${textValue}, ${sql.raw(`"${s.metaValueJson}"`)} = ${jsonStr}::jsonb
+			WHERE ${sql.raw(`"${s.metaId}"`)} = ${metaId}
+		`);
+    return true;
+  }
+  async delete(objectId, key, value) {
+    if (value !== void 0) {
+      const { textValue } = this.serialize(value);
+      const result2 = await this.db.delete(this.table).where(
+        and(
+          eq2(this.columns.objectId, objectId),
+          eq2(this.columns.metaKey, key),
+          eq2(this.columns.metaValue, textValue)
+        )
+      ).returning({ metaId: this.columns.metaId });
+      return result2.length;
+    }
+    const result = await this.db.delete(this.table).where(and(eq2(this.columns.objectId, objectId), eq2(this.columns.metaKey, key))).returning({ metaId: this.columns.metaId });
+    return result.length;
+  }
+  async deleteAllForObject(objectId) {
+    const result = await this.db.delete(this.table).where(eq2(this.columns.objectId, objectId)).returning({ metaId: this.columns.metaId });
+    return result.length;
+  }
+  /**
+   * Convert a raw DB row to MetaEntry using column name mapping.
+   */
+  toMetaEntry(row) {
+    const ts = this.colNames.ts;
+    return {
+      metaId: row[ts.metaId],
+      objectId: row[ts.objectId],
+      metaKey: row[ts.metaKey],
+      metaValue: row[ts.metaValue],
+      metaValueJson: row[ts.metaValueJson]
+    };
+  }
+  serialize(value) {
+    if (value === null || value === void 0) {
+      return { textValue: "", jsonValue: null };
+    }
+    if (typeof value === "string") {
+      try {
+        const parsed = JSON.parse(value);
+        if (typeof parsed === "object" && parsed !== null) {
+          return { textValue: value, jsonValue: parsed };
+        }
+      } catch {
+      }
+      return { textValue: value, jsonValue: null };
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return { textValue: String(value), jsonValue: null };
+    }
+    const textValue = JSON.stringify(value);
+    return { textValue, jsonValue: value };
+  }
+  deserialize(entry) {
+    if (entry.metaValueJson !== null && entry.metaValueJson !== void 0) {
+      return entry.metaValueJson;
+    }
+    if (entry.metaValue === null) return "";
+    try {
+      return JSON.parse(entry.metaValue);
+    } catch {
+      return entry.metaValue;
+    }
+  }
+};
+
+// src/repositories/post-repository.ts
+var PostRepository = class {
+  constructor(db) {
+    this.db = db;
+    const metaCols = {
+      metaId: postmeta.metaId,
+      objectId: postmeta.postId,
+      metaKey: postmeta.metaKey,
+      metaValue: postmeta.metaValue,
+      metaValueJson: postmeta.metaValueJson
+    };
+    const colNames = {
+      table: "postmeta",
+      sql: { metaId: "meta_id", objectId: "post_id", metaKey: "meta_key", metaValue: "meta_value", metaValueJson: "meta_value_json" },
+      ts: { metaId: "metaId", objectId: "postId", metaKey: "metaKey", metaValue: "metaValue", metaValueJson: "metaValueJson" }
+    };
+    this.meta = new MetaRepository(db, postmeta, metaCols, colNames);
+  }
+  db;
+  meta;
+  /**
+   * Create a new post.
+   */
+  async create(input) {
+    const postName = input.postName || this.generateSlug(input.postTitle);
+    const uniqueSlug = await this.ensureUniqueSlug(
+      postName,
+      input.postType ?? "post"
+    );
+    const now = /* @__PURE__ */ new Date();
+    const [row] = await this.db.insert(posts).values({
+      postAuthor: input.postAuthor,
+      postTitle: input.postTitle,
+      postContent: input.postContent ?? "",
+      postExcerpt: input.postExcerpt ?? "",
+      postStatus: input.postStatus ?? "draft",
+      postName: uniqueSlug,
+      postType: input.postType ?? "post",
+      postParent: input.postParent ?? 0,
+      postPassword: input.postPassword ?? "",
+      commentStatus: input.commentStatus ?? "open",
+      pingStatus: input.pingStatus ?? "open",
+      postMimeType: input.postMimeType ?? "",
+      menuOrder: input.menuOrder ?? 0,
+      guid: input.guid ?? "",
+      postDate: now,
+      postDateGmt: now,
+      postModified: now,
+      postModifiedGmt: now
+    }).returning();
+    return row;
+  }
+  /**
+   * Get a post by ID.
+   */
+  async getById(id) {
+    const rows = await this.db.select().from(posts).where(eq3(posts.id, id)).limit(1);
+    return rows[0];
+  }
+  /**
+   * Get a post by slug and type.
+   */
+  async getBySlug(slug, postType = "post") {
+    const rows = await this.db.select().from(posts).where(and2(eq3(posts.postName, slug), eq3(posts.postType, postType))).limit(1);
+    return rows[0];
+  }
+  /**
+   * Update a post. Returns the updated row or undefined if not found.
+   */
+  async update(id, input) {
+    const existing = await this.getById(id);
+    if (!existing) return void 0;
+    const now = /* @__PURE__ */ new Date();
+    const updateData = {
+      postModified: now,
+      postModifiedGmt: now
+    };
+    if (input.postTitle !== void 0) updateData["postTitle"] = input.postTitle;
+    if (input.postContent !== void 0) updateData["postContent"] = input.postContent;
+    if (input.postExcerpt !== void 0) updateData["postExcerpt"] = input.postExcerpt;
+    if (input.postStatus !== void 0) updateData["postStatus"] = input.postStatus;
+    if (input.postType !== void 0) updateData["postType"] = input.postType;
+    if (input.postParent !== void 0) updateData["postParent"] = input.postParent;
+    if (input.postPassword !== void 0) updateData["postPassword"] = input.postPassword;
+    if (input.commentStatus !== void 0) updateData["commentStatus"] = input.commentStatus;
+    if (input.pingStatus !== void 0) updateData["pingStatus"] = input.pingStatus;
+    if (input.menuOrder !== void 0) updateData["menuOrder"] = input.menuOrder;
+    if (input.postName !== void 0) {
+      updateData["postName"] = await this.ensureUniqueSlug(
+        input.postName,
+        input.postType ?? existing.postType,
+        id
+      );
+    }
+    const [row] = await this.db.update(posts).set(updateData).where(eq3(posts.id, id)).returning();
+    return row;
+  }
+  /**
+   * Trash a post (move to trash status, preserving original status in meta).
+   */
+  async trash(id) {
+    const existing = await this.getById(id);
+    if (!existing) return void 0;
+    if (existing.postStatus === "trash") return existing;
+    await this.meta.update(id, "_trash_meta_status", existing.postStatus);
+    return this.update(id, { postStatus: "trash" });
+  }
+  /**
+   * Restore a trashed post to its original status.
+   */
+  async untrash(id) {
+    const existing = await this.getById(id);
+    if (!existing || existing.postStatus !== "trash") return existing;
+    const originalStatus = await this.meta.get(id, "_trash_meta_status");
+    await this.meta.delete(id, "_trash_meta_status");
+    return this.update(id, { postStatus: originalStatus ?? "draft" });
+  }
+  /**
+   * Permanently delete a post and all its metadata.
+   */
+  async deletePermanently(id) {
+    await this.meta.deleteAllForObject(id);
+    const result = await this.db.delete(posts).where(eq3(posts.id, id)).returning({ id: posts.id });
+    return result.length > 0;
+  }
+  /**
+   * Get sticky post IDs.
+   */
+  async getStickyIds() {
+    const rows = await this.db.select({ postId: postmeta.postId }).from(postmeta).where(and2(eq3(postmeta.metaKey, "_sticky"), eq3(postmeta.metaValue, "1")));
+    return rows.map((r) => r.postId);
+  }
+  /**
+   * Set a post as sticky or not.
+   */
+  async setSticky(id, sticky) {
+    if (sticky) {
+      await this.meta.update(id, "_sticky", "1");
+    } else {
+      await this.meta.delete(id, "_sticky");
+    }
+  }
+  /**
+   * Check if a post is sticky.
+   */
+  async isSticky(id) {
+    const value = await this.meta.get(id, "_sticky");
+    return value === "1" || value === 1;
+  }
+  /**
+   * Count posts by type and status.
+   */
+  async countByStatus(postType = "post") {
+    const rows = await this.db.select({
+      status: posts.postStatus,
+      count: sql2`count(*)::int`
+    }).from(posts).where(eq3(posts.postType, postType)).groupBy(posts.postStatus);
+    const result = {};
+    for (const row of rows) {
+      result[row.status] = row.count;
+    }
+    return result;
+  }
+  /**
+   * Generate a URL-safe slug from a title.
+   */
+  generateSlug(title) {
+    return title.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9_\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 200);
+  }
+  /**
+   * Ensure a slug is unique within a post type.
+   * Appends -2, -3, etc. if needed.
+   */
+  async ensureUniqueSlug(slug, postType, excludeId) {
+    let candidate = slug;
+    let suffix = 2;
+    while (true) {
+      const conditions = [eq3(posts.postName, candidate), eq3(posts.postType, postType)];
+      if (excludeId !== void 0) {
+        conditions.push(sql2`${posts.id} != ${excludeId}`);
+      }
+      const existing = await this.db.select({ id: posts.id }).from(posts).where(and2(...conditions)).limit(1);
+      if (existing.length === 0) return candidate;
+      candidate = `${slug}-${suffix}`;
+      suffix++;
+    }
+  }
+};
+
+// src/repositories/taxonomy-repository.ts
+import { eq as eq4, and as and3, sql as sql3, inArray as inArray2 } from "drizzle-orm";
+var TaxonomyRepository = class {
+  constructor(db) {
+    this.db = db;
+    const metaCols = {
+      metaId: termmeta.metaId,
+      objectId: termmeta.termId,
+      metaKey: termmeta.metaKey,
+      metaValue: termmeta.metaValue,
+      metaValueJson: termmeta.metaValueJson
+    };
+    const colNames = {
+      table: "termmeta",
+      sql: { metaId: "meta_id", objectId: "term_id", metaKey: "meta_key", metaValue: "meta_value", metaValueJson: "meta_value_json" },
+      ts: { metaId: "metaId", objectId: "termId", metaKey: "metaKey", metaValue: "metaValue", metaValueJson: "metaValueJson" }
+    };
+    this.meta = new MetaRepository(db, termmeta, metaCols, colNames);
+  }
+  db;
+  meta;
+  /**
+   * Create a new term in a taxonomy.
+   */
+  async createTerm(input) {
+    const slug = input.slug || this.generateSlug(input.name);
+    const uniqueSlug = await this.ensureUniqueSlug(slug);
+    const [term] = await this.db.insert(terms).values({
+      name: input.name,
+      slug: uniqueSlug
+    }).returning();
+    const [tt] = await this.db.insert(termTaxonomy).values({
+      termId: term.termId,
+      taxonomy: input.taxonomy,
+      description: input.description ?? "",
+      parent: input.parent ?? 0,
+      count: 0
+    }).returning();
+    return {
+      termId: term.termId,
+      name: term.name,
+      slug: term.slug,
+      termGroup: term.termGroup,
+      termTaxonomyId: tt.termTaxonomyId,
+      taxonomy: tt.taxonomy,
+      description: tt.description,
+      parent: tt.parent,
+      count: tt.count
+    };
+  }
+  /**
+   * Get a term by ID and taxonomy.
+   */
+  async getTermById(termId, taxonomy) {
+    const rows = await this.db.select({
+      termId: terms.termId,
+      name: terms.name,
+      slug: terms.slug,
+      termGroup: terms.termGroup,
+      termTaxonomyId: termTaxonomy.termTaxonomyId,
+      taxonomy: termTaxonomy.taxonomy,
+      description: termTaxonomy.description,
+      parent: termTaxonomy.parent,
+      count: termTaxonomy.count
+    }).from(terms).innerJoin(termTaxonomy, eq4(terms.termId, termTaxonomy.termId)).where(and3(eq4(terms.termId, termId), eq4(termTaxonomy.taxonomy, taxonomy))).limit(1);
+    return rows[0];
+  }
+  /**
+   * Get a term by slug and taxonomy.
+   */
+  async getTermBySlug(slug, taxonomy) {
+    const rows = await this.db.select({
+      termId: terms.termId,
+      name: terms.name,
+      slug: terms.slug,
+      termGroup: terms.termGroup,
+      termTaxonomyId: termTaxonomy.termTaxonomyId,
+      taxonomy: termTaxonomy.taxonomy,
+      description: termTaxonomy.description,
+      parent: termTaxonomy.parent,
+      count: termTaxonomy.count
+    }).from(terms).innerJoin(termTaxonomy, eq4(terms.termId, termTaxonomy.termId)).where(and3(eq4(terms.slug, slug), eq4(termTaxonomy.taxonomy, taxonomy))).limit(1);
+    return rows[0];
+  }
+  /**
+   * Get all terms in a taxonomy.
+   */
+  async getTerms(taxonomy, parentId) {
+    const conditions = [eq4(termTaxonomy.taxonomy, taxonomy)];
+    if (parentId !== void 0) {
+      conditions.push(eq4(termTaxonomy.parent, parentId));
+    }
+    const rows = await this.db.select({
+      termId: terms.termId,
+      name: terms.name,
+      slug: terms.slug,
+      termGroup: terms.termGroup,
+      termTaxonomyId: termTaxonomy.termTaxonomyId,
+      taxonomy: termTaxonomy.taxonomy,
+      description: termTaxonomy.description,
+      parent: termTaxonomy.parent,
+      count: termTaxonomy.count
+    }).from(terms).innerJoin(termTaxonomy, eq4(terms.termId, termTaxonomy.termId)).where(and3(...conditions)).orderBy(terms.name);
+    return rows;
+  }
+  /**
+   * Assign terms to an object (post).
+   */
+  async setObjectTerms(objectId, termTaxonomyIds) {
+    const existingTtIds = termTaxonomyIds.length > 0 ? await this.db.select({ taxonomy: termTaxonomy.taxonomy }).from(termTaxonomy).where(inArray2(termTaxonomy.termTaxonomyId, termTaxonomyIds)) : [];
+    const taxonomies = [...new Set(existingTtIds.map((r) => r.taxonomy))];
+    if (taxonomies.length > 0) {
+      const allTtIds = await this.db.select({ termTaxonomyId: termTaxonomy.termTaxonomyId }).from(termTaxonomy).where(inArray2(termTaxonomy.taxonomy, taxonomies));
+      const allTtIdValues = allTtIds.map((r) => r.termTaxonomyId);
+      if (allTtIdValues.length > 0) {
+        await this.db.delete(termRelationships).where(
+          and3(
+            eq4(termRelationships.objectId, objectId),
+            inArray2(termRelationships.termTaxonomyId, allTtIdValues)
+          )
+        );
+      }
+    }
+    if (termTaxonomyIds.length > 0) {
+      await this.db.insert(termRelationships).values(
+        termTaxonomyIds.map((ttId, i) => ({
+          objectId,
+          termTaxonomyId: ttId,
+          termOrder: i
+        }))
+      ).onConflictDoNothing();
+    }
+    await this.recountTerms(termTaxonomyIds);
+  }
+  /**
+   * Get terms assigned to an object.
+   */
+  async getObjectTerms(objectId, taxonomy) {
+    const conditions = [eq4(termRelationships.objectId, objectId)];
+    if (taxonomy) {
+      conditions.push(eq4(termTaxonomy.taxonomy, taxonomy));
+    }
+    const rows = await this.db.select({
+      termId: terms.termId,
+      name: terms.name,
+      slug: terms.slug,
+      termGroup: terms.termGroup,
+      termTaxonomyId: termTaxonomy.termTaxonomyId,
+      taxonomy: termTaxonomy.taxonomy,
+      description: termTaxonomy.description,
+      parent: termTaxonomy.parent,
+      count: termTaxonomy.count
+    }).from(termRelationships).innerJoin(
+      termTaxonomy,
+      eq4(termRelationships.termTaxonomyId, termTaxonomy.termTaxonomyId)
+    ).innerJoin(terms, eq4(termTaxonomy.termId, terms.termId)).where(and3(...conditions)).orderBy(termRelationships.termOrder);
+    return rows;
+  }
+  /**
+   * Delete a term and all its relationships.
+   */
+  async deleteTerm(termId, taxonomy) {
+    const term = await this.getTermById(termId, taxonomy);
+    if (!term) return false;
+    await this.db.delete(termRelationships).where(eq4(termRelationships.termTaxonomyId, term.termTaxonomyId));
+    await this.db.delete(termTaxonomy).where(eq4(termTaxonomy.termTaxonomyId, term.termTaxonomyId));
+    const otherUsages = await this.db.select({ termTaxonomyId: termTaxonomy.termTaxonomyId }).from(termTaxonomy).where(eq4(termTaxonomy.termId, termId)).limit(1);
+    if (otherUsages.length === 0) {
+      await this.db.delete(terms).where(eq4(terms.termId, termId));
+    }
+    await this.meta.deleteAllForObject(termId);
+    return true;
+  }
+  /**
+   * Recount the number of objects assigned to terms.
+   */
+  async recountTerms(termTaxonomyIds) {
+    for (const ttId of termTaxonomyIds) {
+      const [result] = await this.db.select({ count: sql3`count(*)::int` }).from(termRelationships).where(eq4(termRelationships.termTaxonomyId, ttId));
+      await this.db.update(termTaxonomy).set({ count: result.count }).where(eq4(termTaxonomy.termTaxonomyId, ttId));
+    }
+  }
+  generateSlug(name) {
+    return name.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9_\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").substring(0, 200);
+  }
+  async ensureUniqueSlug(slug, excludeId) {
+    let candidate = slug;
+    let suffix = 2;
+    while (true) {
+      const conditions = [eq4(terms.slug, candidate)];
+      if (excludeId !== void 0) {
+        conditions.push(sql3`${terms.termId} != ${excludeId}`);
+      }
+      const existing = await this.db.select({ termId: terms.termId }).from(terms).where(and3(...conditions)).limit(1);
+      if (existing.length === 0) return candidate;
+      candidate = `${slug}-${suffix}`;
+      suffix++;
+    }
+  }
+};
+
+// src/repositories/revision-repository.ts
+import { eq as eq5, and as and4, desc, sql as sql4 } from "drizzle-orm";
+var REVISION_FIELDS = [
+  "postTitle",
+  "postContent",
+  "postExcerpt"
+];
+var RevisionRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  /**
+   * Create a revision snapshot of a post.
+   * Returns undefined if nothing changed since the last revision.
+   *
+   * @param post - The current state of the post (before or after update)
+   * @param authorId - The user who made the change
+   */
+  async createRevision(post, authorId) {
+    const lastRevision = await this.getLatest(post.id);
+    if (lastRevision && !this.hasChanges(post, lastRevision)) {
+      return void 0;
+    }
+    const now = /* @__PURE__ */ new Date();
+    const [revision] = await this.db.insert(posts).values({
+      postAuthor: authorId,
+      postDate: now,
+      postDateGmt: now,
+      postModified: now,
+      postModifiedGmt: now,
+      postTitle: post.postTitle,
+      postContent: post.postContent,
+      postExcerpt: post.postExcerpt,
+      postStatus: "inherit",
+      postName: `${post.id}-revision-v1`,
+      postType: "revision",
+      postParent: post.id
+    }).returning();
+    return revision;
+  }
+  /**
+   * Get all revisions for a post, newest first.
+   */
+  async getRevisions(postId, limit) {
+    let query = this.db.select().from(posts).where(and4(eq5(posts.postParent, postId), eq5(posts.postType, "revision"))).orderBy(desc(posts.postDate)).$dynamic();
+    if (limit !== void 0) {
+      query = query.limit(limit);
+    }
+    return await query;
+  }
+  /**
+   * Get the most recent revision for a post.
+   */
+  async getLatest(postId) {
+    const rows = await this.getRevisions(postId, 1);
+    return rows[0];
+  }
+  /**
+   * Get a specific revision by ID.
+   */
+  async getById(revisionId) {
+    const rows = await this.db.select().from(posts).where(and4(eq5(posts.id, revisionId), eq5(posts.postType, "revision"))).limit(1);
+    return rows[0];
+  }
+  /**
+   * Restore a post to a specific revision.
+   * Returns the updated post.
+   */
+  async restore(postId, revisionId) {
+    const revision = await this.getById(revisionId);
+    if (!revision || revision.postParent !== postId) return void 0;
+    const now = /* @__PURE__ */ new Date();
+    const [updated] = await this.db.update(posts).set({
+      postTitle: revision.postTitle,
+      postContent: revision.postContent,
+      postExcerpt: revision.postExcerpt,
+      postModified: now,
+      postModifiedGmt: now
+    }).where(eq5(posts.id, postId)).returning();
+    return updated;
+  }
+  /**
+   * Delete old revisions beyond the keep limit.
+   */
+  async cleanup(postId, keepCount) {
+    const revisions = await this.getRevisions(postId);
+    if (revisions.length <= keepCount) return 0;
+    const toDelete = revisions.slice(keepCount);
+    const idsToDelete = toDelete.map((r) => r.id);
+    if (idsToDelete.length === 0) return 0;
+    const result = await this.db.delete(posts).where(
+      and4(
+        sql4`${posts.id} IN (${sql4.join(
+          idsToDelete.map((id) => sql4`${id}`),
+          sql4`, `
+        )})`,
+        eq5(posts.postType, "revision")
+      )
+    ).returning({ id: posts.id });
+    return result.length;
+  }
+  /**
+   * Count revisions for a post.
+   */
+  async count(postId) {
+    const [result] = await this.db.select({ count: sql4`count(*)::int` }).from(posts).where(and4(eq5(posts.postParent, postId), eq5(posts.postType, "revision")));
+    return result.count;
+  }
+  /**
+   * Check if any tracked field changed between two post states.
+   */
+  hasChanges(current, previous) {
+    for (const field of REVISION_FIELDS) {
+      if (current[field] !== previous[field]) return true;
+    }
+    return false;
+  }
+};
+export {
+  MetaRepository,
+  ObjectCache,
+  OptionsRepository,
+  PostRepository,
+  RevisionRepository,
+  TaxonomyRepository,
+  commentmeta,
+  comments,
+  createConnection,
+  links,
+  options,
+  postmeta,
+  posts,
+  scheduledEvents,
+  sessions,
+  termRelationships,
+  termTaxonomy,
+  termmeta,
+  terms,
+  usermeta,
+  users
+};
 //# sourceMappingURL=index.js.map