@newcms/database 0.1.1 → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1527 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc2) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MetaRepository: () => MetaRepository,
+  ObjectCache: () => ObjectCache,
+  OptionsRepository: () => OptionsRepository,
+  PostRepository: () => PostRepository,
+  RevisionRepository: () => RevisionRepository,
+  TaxonomyRepository: () => TaxonomyRepository,
+  commentmeta: () => commentmeta,
+  comments: () => comments,
+  createConnection: () => createConnection,
+  links: () => links,
+  options: () => options,
+  postmeta: () => postmeta,
+  posts: () => posts,
+  scheduledEvents: () => scheduledEvents,
+  sessions: () => sessions,
+  termRelationships: () => termRelationships,
+  termTaxonomy: () => termTaxonomy,
+  termmeta: () => termmeta,
+  terms: () => terms,
+  usermeta: () => usermeta,
+  users: () => users
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/connection.ts
+var import_postgres_js = require("drizzle-orm/postgres-js");
+var import_postgres = __toESM(require("postgres"), 1);
+
+// 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
+var import_pg_core2 = require("drizzle-orm/pg-core");
+
+// src/schema/users.ts
+var import_pg_core = require("drizzle-orm/pg-core");
+var users = (0, import_pg_core.pgTable)(
+  "users",
+  {
+    id: (0, import_pg_core.serial)("id").primaryKey(),
+    userLogin: (0, import_pg_core.varchar)("user_login", { length: 60 }).notNull().unique(),
+    userPass: (0, import_pg_core.varchar)("user_pass", { length: 255 }).notNull().default(""),
+    userNicename: (0, import_pg_core.varchar)("user_nicename", { length: 50 }).notNull().default(""),
+    userEmail: (0, import_pg_core.varchar)("user_email", { length: 100 }).notNull().unique(),
+    userUrl: (0, import_pg_core.varchar)("user_url", { length: 100 }).notNull().default(""),
+    userRegistered: (0, import_pg_core.timestamp)("user_registered", { withTimezone: true }).notNull().defaultNow(),
+    userActivationKey: (0, import_pg_core.varchar)("user_activation_key", { length: 255 }).notNull().default(""),
+    userStatus: (0, import_pg_core.varchar)("user_status", { length: 20 }).notNull().default("active"),
+    displayName: (0, import_pg_core.varchar)("display_name", { length: 250 }).notNull().default("")
+  },
+  (table) => [
+    (0, import_pg_core.index)("idx_user_login").on(table.userLogin),
+    (0, import_pg_core.index)("idx_user_nicename").on(table.userNicename),
+    (0, import_pg_core.index)("idx_user_email").on(table.userEmail)
+  ]
+);
+var usermeta = (0, import_pg_core.pgTable)(
+  "usermeta",
+  {
+    umetaId: (0, import_pg_core.serial)("umeta_id").primaryKey(),
+    userId: (0, import_pg_core.serial)("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+    metaKey: (0, import_pg_core.varchar)("meta_key", { length: 255 }),
+    metaValue: (0, import_pg_core.text)("meta_value"),
+    metaValueJson: (0, import_pg_core.jsonb)("meta_value_json")
+  },
+  (table) => [
+    (0, import_pg_core.index)("idx_usermeta_user_id").on(table.userId),
+    (0, import_pg_core.index)("idx_usermeta_meta_key").on(table.metaKey)
+  ]
+);
+
+// src/schema/posts.ts
+var posts = (0, import_pg_core2.pgTable)(
+  "posts",
+  {
+    id: (0, import_pg_core2.serial)("id").primaryKey(),
+    postAuthor: (0, import_pg_core2.bigint)("post_author", { mode: "number" }).notNull().default(0).references(() => users.id),
+    postDate: (0, import_pg_core2.timestamp)("post_date", { withTimezone: true }).notNull().defaultNow(),
+    postDateGmt: (0, import_pg_core2.timestamp)("post_date_gmt", { withTimezone: true }).notNull().defaultNow(),
+    postContent: (0, import_pg_core2.text)("post_content").notNull().default(""),
+    postTitle: (0, import_pg_core2.text)("post_title").notNull().default(""),
+    postExcerpt: (0, import_pg_core2.text)("post_excerpt").notNull().default(""),
+    postStatus: (0, import_pg_core2.varchar)("post_status", { length: 20 }).notNull().default("publish"),
+    commentStatus: (0, import_pg_core2.varchar)("comment_status", { length: 20 }).notNull().default("open"),
+    pingStatus: (0, import_pg_core2.varchar)("ping_status", { length: 20 }).notNull().default("open"),
+    postPassword: (0, import_pg_core2.varchar)("post_password", { length: 255 }).notNull().default(""),
+    postName: (0, import_pg_core2.varchar)("post_name", { length: 200 }).notNull().default(""),
+    toPing: (0, import_pg_core2.text)("to_ping").notNull().default(""),
+    pinged: (0, import_pg_core2.text)("pinged").notNull().default(""),
+    postModified: (0, import_pg_core2.timestamp)("post_modified", { withTimezone: true }).notNull().defaultNow(),
+    postModifiedGmt: (0, import_pg_core2.timestamp)("post_modified_gmt", { withTimezone: true }).notNull().defaultNow(),
+    postContentFiltered: (0, import_pg_core2.text)("post_content_filtered").notNull().default(""),
+    postParent: (0, import_pg_core2.bigint)("post_parent", { mode: "number" }).notNull().default(0),
+    guid: (0, import_pg_core2.varchar)("guid", { length: 255 }).notNull().default(""),
+    menuOrder: (0, import_pg_core2.bigint)("menu_order", { mode: "number" }).notNull().default(0),
+    postType: (0, import_pg_core2.varchar)("post_type", { length: 20 }).notNull().default("post"),
+    postMimeType: (0, import_pg_core2.varchar)("post_mime_type", { length: 100 }).notNull().default(""),
+    commentCount: (0, import_pg_core2.bigint)("comment_count", { mode: "number" }).notNull().default(0)
+  },
+  (table) => [
+    (0, import_pg_core2.index)("idx_post_name").on(table.postName),
+    (0, import_pg_core2.index)("idx_post_type_status_date").on(table.postType, table.postStatus, table.postDate),
+    (0, import_pg_core2.index)("idx_post_parent").on(table.postParent),
+    (0, import_pg_core2.index)("idx_post_author").on(table.postAuthor)
+  ]
+);
+var postmeta = (0, import_pg_core2.pgTable)(
+  "postmeta",
+  {
+    metaId: (0, import_pg_core2.serial)("meta_id").primaryKey(),
+    postId: (0, import_pg_core2.bigint)("post_id", { mode: "number" }).notNull().references(() => posts.id, { onDelete: "cascade" }),
+    metaKey: (0, import_pg_core2.varchar)("meta_key", { length: 255 }),
+    metaValue: (0, import_pg_core2.text)("meta_value"),
+    metaValueJson: (0, import_pg_core2.jsonb)("meta_value_json")
+  },
+  (table) => [
+    (0, import_pg_core2.index)("idx_postmeta_post_id").on(table.postId),
+    (0, import_pg_core2.index)("idx_postmeta_meta_key").on(table.metaKey),
+    (0, import_pg_core2.index)("idx_postmeta_post_key").on(table.postId, table.metaKey)
+  ]
+);
+
+// src/schema/comments.ts
+var import_pg_core3 = require("drizzle-orm/pg-core");
+var comments = (0, import_pg_core3.pgTable)(
+  "comments",
+  {
+    commentId: (0, import_pg_core3.serial)("comment_id").primaryKey(),
+    commentPostId: (0, import_pg_core3.bigint)("comment_post_id", { mode: "number" }).notNull().default(0).references(() => posts.id, { onDelete: "cascade" }),
+    commentAuthor: (0, import_pg_core3.text)("comment_author").notNull().default(""),
+    commentAuthorEmail: (0, import_pg_core3.varchar)("comment_author_email", { length: 100 }).notNull().default(""),
+    commentAuthorUrl: (0, import_pg_core3.varchar)("comment_author_url", { length: 200 }).notNull().default(""),
+    commentAuthorIp: (0, import_pg_core3.varchar)("comment_author_ip", { length: 100 }).notNull().default(""),
+    commentDate: (0, import_pg_core3.timestamp)("comment_date", { withTimezone: true }).notNull().defaultNow(),
+    commentDateGmt: (0, import_pg_core3.timestamp)("comment_date_gmt", { withTimezone: true }).notNull().defaultNow(),
+    commentContent: (0, import_pg_core3.text)("comment_content").notNull().default(""),
+    commentKarma: (0, import_pg_core3.bigint)("comment_karma", { mode: "number" }).notNull().default(0),
+    commentApproved: (0, import_pg_core3.varchar)("comment_approved", { length: 20 }).notNull().default("1"),
+    commentAgent: (0, import_pg_core3.varchar)("comment_agent", { length: 255 }).notNull().default(""),
+    commentType: (0, import_pg_core3.varchar)("comment_type", { length: 20 }).notNull().default("comment"),
+    commentParent: (0, import_pg_core3.bigint)("comment_parent", { mode: "number" }).notNull().default(0),
+    userId: (0, import_pg_core3.bigint)("user_id", { mode: "number" }).notNull().default(0).references(() => users.id)
+  },
+  (table) => [
+    (0, import_pg_core3.index)("idx_comment_post_id").on(table.commentPostId),
+    (0, import_pg_core3.index)("idx_comment_approved_date_gmt").on(table.commentApproved, table.commentDateGmt),
+    (0, import_pg_core3.index)("idx_comment_date_gmt").on(table.commentDateGmt),
+    (0, import_pg_core3.index)("idx_comment_parent").on(table.commentParent),
+    (0, import_pg_core3.index)("idx_comment_author_email").on(table.commentAuthorEmail)
+  ]
+);
+var commentmeta = (0, import_pg_core3.pgTable)(
+  "commentmeta",
+  {
+    metaId: (0, import_pg_core3.serial)("meta_id").primaryKey(),
+    commentId: (0, import_pg_core3.bigint)("comment_id", { mode: "number" }).notNull().references(() => comments.commentId, { onDelete: "cascade" }),
+    metaKey: (0, import_pg_core3.varchar)("meta_key", { length: 255 }),
+    metaValue: (0, import_pg_core3.text)("meta_value"),
+    metaValueJson: (0, import_pg_core3.jsonb)("meta_value_json")
+  },
+  (table) => [
+    (0, import_pg_core3.index)("idx_commentmeta_comment_id").on(table.commentId),
+    (0, import_pg_core3.index)("idx_commentmeta_meta_key").on(table.metaKey)
+  ]
+);
+
+// src/schema/terms.ts
+var import_pg_core4 = require("drizzle-orm/pg-core");
+var terms = (0, import_pg_core4.pgTable)(
+  "terms",
+  {
+    termId: (0, import_pg_core4.serial)("term_id").primaryKey(),
+    name: (0, import_pg_core4.varchar)("name", { length: 200 }).notNull().default(""),
+    slug: (0, import_pg_core4.varchar)("slug", { length: 200 }).notNull().default(""),
+    termGroup: (0, import_pg_core4.bigint)("term_group", { mode: "number" }).notNull().default(0)
+  },
+  (table) => [(0, import_pg_core4.index)("idx_term_slug").on(table.slug), (0, import_pg_core4.index)("idx_term_name").on(table.name)]
+);
+var termTaxonomy = (0, import_pg_core4.pgTable)(
+  "term_taxonomy",
+  {
+    termTaxonomyId: (0, import_pg_core4.serial)("term_taxonomy_id").primaryKey(),
+    termId: (0, import_pg_core4.bigint)("term_id", { mode: "number" }).notNull().references(() => terms.termId, { onDelete: "cascade" }),
+    taxonomy: (0, import_pg_core4.varchar)("taxonomy", { length: 32 }).notNull().default(""),
+    description: (0, import_pg_core4.text)("description").notNull().default(""),
+    parent: (0, import_pg_core4.bigint)("parent", { mode: "number" }).notNull().default(0),
+    count: (0, import_pg_core4.bigint)("count", { mode: "number" }).notNull().default(0)
+  },
+  (table) => [
+    (0, import_pg_core4.uniqueIndex)("idx_term_id_taxonomy").on(table.termId, table.taxonomy),
+    (0, import_pg_core4.index)("idx_taxonomy").on(table.taxonomy)
+  ]
+);
+var termRelationships = (0, import_pg_core4.pgTable)(
+  "term_relationships",
+  {
+    objectId: (0, import_pg_core4.bigint)("object_id", { mode: "number" }).notNull().references(() => posts.id, { onDelete: "cascade" }),
+    termTaxonomyId: (0, import_pg_core4.bigint)("term_taxonomy_id", { mode: "number" }).notNull().references(() => termTaxonomy.termTaxonomyId, { onDelete: "cascade" }),
+    termOrder: (0, import_pg_core4.bigint)("term_order", { mode: "number" }).notNull().default(0)
+  },
+  (table) => [
+    (0, import_pg_core4.primaryKey)({ columns: [table.objectId, table.termTaxonomyId] }),
+    (0, import_pg_core4.index)("idx_term_taxonomy_id").on(table.termTaxonomyId)
+  ]
+);
+var termmeta = (0, import_pg_core4.pgTable)(
+  "termmeta",
+  {
+    metaId: (0, import_pg_core4.serial)("meta_id").primaryKey(),
+    termId: (0, import_pg_core4.bigint)("term_id", { mode: "number" }).notNull().references(() => terms.termId, { onDelete: "cascade" }),
+    metaKey: (0, import_pg_core4.varchar)("meta_key", { length: 255 }),
+    metaValue: (0, import_pg_core4.text)("meta_value"),
+    metaValueJson: (0, import_pg_core4.jsonb)("meta_value_json")
+  },
+  (table) => [
+    (0, import_pg_core4.index)("idx_termmeta_term_id").on(table.termId),
+    (0, import_pg_core4.index)("idx_termmeta_meta_key").on(table.metaKey)
+  ]
+);
+
+// src/schema/options.ts
+var import_pg_core5 = require("drizzle-orm/pg-core");
+var options = (0, import_pg_core5.pgTable)(
+  "options",
+  {
+    optionId: (0, import_pg_core5.serial)("option_id").primaryKey(),
+    optionName: (0, import_pg_core5.varchar)("option_name", { length: 191 }).notNull().unique(),
+    optionValue: (0, import_pg_core5.text)("option_value").notNull().default(""),
+    optionValueJson: (0, import_pg_core5.jsonb)("option_value_json"),
+    autoload: (0, import_pg_core5.boolean)("autoload").notNull().default(true)
+  },
+  (table) => [
+    (0, import_pg_core5.uniqueIndex)("idx_option_name").on(table.optionName),
+    (0, import_pg_core5.index)("idx_autoload").on(table.autoload)
+  ]
+);
+
+// src/schema/links.ts
+var import_pg_core6 = require("drizzle-orm/pg-core");
+var links = (0, import_pg_core6.pgTable)(
+  "links",
+  {
+    linkId: (0, import_pg_core6.serial)("link_id").primaryKey(),
+    linkUrl: (0, import_pg_core6.varchar)("link_url", { length: 255 }).notNull().default(""),
+    linkName: (0, import_pg_core6.varchar)("link_name", { length: 255 }).notNull().default(""),
+    linkImage: (0, import_pg_core6.varchar)("link_image", { length: 255 }).notNull().default(""),
+    linkTarget: (0, import_pg_core6.varchar)("link_target", { length: 25 }).notNull().default(""),
+    linkDescription: (0, import_pg_core6.varchar)("link_description", { length: 255 }).notNull().default(""),
+    linkVisible: (0, import_pg_core6.varchar)("link_visible", { length: 20 }).notNull().default("Y"),
+    linkOwner: (0, import_pg_core6.bigint)("link_owner", { mode: "number" }).notNull().default(1),
+    linkRating: (0, import_pg_core6.bigint)("link_rating", { mode: "number" }).notNull().default(0),
+    linkUpdated: (0, import_pg_core6.timestamp)("link_updated", { withTimezone: true }).notNull().defaultNow(),
+    linkRel: (0, import_pg_core6.varchar)("link_rel", { length: 255 }).notNull().default(""),
+    linkNotes: (0, import_pg_core6.text)("link_notes").notNull().default(""),
+    linkRss: (0, import_pg_core6.varchar)("link_rss", { length: 255 }).notNull().default("")
+  },
+  (table) => [(0, import_pg_core6.index)("idx_link_visible").on(table.linkVisible)]
+);
+
+// src/schema/sessions.ts
+var import_pg_core7 = require("drizzle-orm/pg-core");
+var sessions = (0, import_pg_core7.pgTable)(
+  "sessions",
+  {
+    id: (0, import_pg_core7.serial)("id").primaryKey(),
+    userId: (0, import_pg_core7.bigint)("user_id", { mode: "number" }).notNull().references(() => users.id, { onDelete: "cascade" }),
+    tokenHash: (0, import_pg_core7.varchar)("token_hash", { length: 255 }).notNull().unique(),
+    createdAt: (0, import_pg_core7.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow(),
+    expiresAt: (0, import_pg_core7.timestamp)("expires_at", { withTimezone: true }).notNull(),
+    ip: (0, import_pg_core7.varchar)("ip", { length: 45 }).notNull().default(""),
+    userAgent: (0, import_pg_core7.varchar)("user_agent", { length: 500 }).notNull().default(""),
+    data: (0, import_pg_core7.jsonb)("data")
+  },
+  (table) => [
+    (0, import_pg_core7.index)("idx_session_user_id").on(table.userId),
+    (0, import_pg_core7.index)("idx_session_token_hash").on(table.tokenHash),
+    (0, import_pg_core7.index)("idx_session_expires_at").on(table.expiresAt)
+  ]
+);
+
+// src/schema/scheduled-events.ts
+var import_pg_core8 = require("drizzle-orm/pg-core");
+var scheduledEvents = (0, import_pg_core8.pgTable)(
+  "scheduled_events",
+  {
+    id: (0, import_pg_core8.serial)("id").primaryKey(),
+    hook: (0, import_pg_core8.varchar)("hook", { length: 255 }).notNull(),
+    args: (0, import_pg_core8.jsonb)("args").notNull().default("[]"),
+    schedule: (0, import_pg_core8.varchar)("schedule", { length: 50 }),
+    intervalSeconds: (0, import_pg_core8.bigint)("interval_seconds", { mode: "number" }),
+    nextRunAt: (0, import_pg_core8.timestamp)("next_run_at", { withTimezone: true }).notNull(),
+    createdAt: (0, import_pg_core8.timestamp)("created_at", { withTimezone: true }).notNull().defaultNow(),
+    status: (0, import_pg_core8.varchar)("status", { length: 20 }).notNull().default("pending")
+  },
+  (table) => [
+    (0, import_pg_core8.index)("idx_scheduled_hook").on(table.hook),
+    (0, import_pg_core8.index)("idx_scheduled_next_run").on(table.nextRunAt),
+    (0, import_pg_core8.index)("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 = (0, import_postgres.default)({
+    host: cfg.host,
+    port: cfg.port,
+    database: cfg.database,
+    user: cfg.user,
+    password: cfg.password,
+    max: cfg.maxConnections ?? 10
+  });
+  const db = (0, import_postgres_js.drizzle)(client, { schema: schema_exports });
+  return { db, client };
+}
+
+// src/cache/object-cache.ts
+var import_ioredis = __toESM(require("ioredis"), 1);
+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 import_ioredis.default({
+      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
+var import_drizzle_orm = require("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((0, import_drizzle_orm.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((0, import_drizzle_orm.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((0, import_drizzle_orm.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((0, import_drizzle_orm.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((0, import_drizzle_orm.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((0, import_drizzle_orm.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
+var import_drizzle_orm3 = require("drizzle-orm");
+
+// src/repositories/meta-repository.ts
+var import_drizzle_orm2 = require("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((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(this.columns.objectId, objectId), (0, import_drizzle_orm2.eq)(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((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(this.columns.objectId, objectId), (0, import_drizzle_orm2.eq)(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((0, import_drizzle_orm2.eq)(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((0, import_drizzle_orm2.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(import_drizzle_orm2.sql`
+			INSERT INTO ${import_drizzle_orm2.sql.raw(`"${t}"`)} (${import_drizzle_orm2.sql.raw(`"${s.objectId}"`)}, ${import_drizzle_orm2.sql.raw(`"${s.metaKey}"`)}, ${import_drizzle_orm2.sql.raw(`"${s.metaValue}"`)}, ${import_drizzle_orm2.sql.raw(`"${s.metaValueJson}"`)})
+			VALUES (${objectId}, ${key}, ${textValue}, ${jsonStr}::jsonb)
+			RETURNING ${import_drizzle_orm2.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((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(this.columns.objectId, objectId), (0, import_drizzle_orm2.eq)(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(import_drizzle_orm2.sql`
+			UPDATE ${import_drizzle_orm2.sql.raw(`"${t}"`)}
+			SET ${import_drizzle_orm2.sql.raw(`"${s.metaValue}"`)} = ${textValue}, ${import_drizzle_orm2.sql.raw(`"${s.metaValueJson}"`)} = ${jsonStr}::jsonb
+			WHERE ${import_drizzle_orm2.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(
+        (0, import_drizzle_orm2.and)(
+          (0, import_drizzle_orm2.eq)(this.columns.objectId, objectId),
+          (0, import_drizzle_orm2.eq)(this.columns.metaKey, key),
+          (0, import_drizzle_orm2.eq)(this.columns.metaValue, textValue)
+        )
+      ).returning({ metaId: this.columns.metaId });
+      return result2.length;
+    }
+    const result = await this.db.delete(this.table).where((0, import_drizzle_orm2.and)((0, import_drizzle_orm2.eq)(this.columns.objectId, objectId), (0, import_drizzle_orm2.eq)(this.columns.metaKey, key))).returning({ metaId: this.columns.metaId });
+    return result.length;
+  }
+  async deleteAllForObject(objectId) {
+    const result = await this.db.delete(this.table).where((0, import_drizzle_orm2.eq)(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((0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(posts.postName, slug), (0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.eq)(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((0, import_drizzle_orm3.and)((0, import_drizzle_orm3.eq)(postmeta.metaKey, "_sticky"), (0, import_drizzle_orm3.eq)(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: import_drizzle_orm3.sql`count(*)::int`
+    }).from(posts).where((0, import_drizzle_orm3.eq)(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 = [(0, import_drizzle_orm3.eq)(posts.postName, candidate), (0, import_drizzle_orm3.eq)(posts.postType, postType)];
+      if (excludeId !== void 0) {
+        conditions.push(import_drizzle_orm3.sql`${posts.id} != ${excludeId}`);
+      }
+      const existing = await this.db.select({ id: posts.id }).from(posts).where((0, import_drizzle_orm3.and)(...conditions)).limit(1);
+      if (existing.length === 0) return candidate;
+      candidate = `${slug}-${suffix}`;
+      suffix++;
+    }
+  }
+};
+
+// src/repositories/taxonomy-repository.ts
+var import_drizzle_orm4 = require("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, (0, import_drizzle_orm4.eq)(terms.termId, termTaxonomy.termId)).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(terms.termId, termId), (0, import_drizzle_orm4.eq)(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, (0, import_drizzle_orm4.eq)(terms.termId, termTaxonomy.termId)).where((0, import_drizzle_orm4.and)((0, import_drizzle_orm4.eq)(terms.slug, slug), (0, import_drizzle_orm4.eq)(termTaxonomy.taxonomy, taxonomy))).limit(1);
+    return rows[0];
+  }
+  /**
+   * Get all terms in a taxonomy.
+   */
+  async getTerms(taxonomy, parentId) {
+    const conditions = [(0, import_drizzle_orm4.eq)(termTaxonomy.taxonomy, taxonomy)];
+    if (parentId !== void 0) {
+      conditions.push((0, import_drizzle_orm4.eq)(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, (0, import_drizzle_orm4.eq)(terms.termId, termTaxonomy.termId)).where((0, import_drizzle_orm4.and)(...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((0, import_drizzle_orm4.inArray)(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((0, import_drizzle_orm4.inArray)(termTaxonomy.taxonomy, taxonomies));
+      const allTtIdValues = allTtIds.map((r) => r.termTaxonomyId);
+      if (allTtIdValues.length > 0) {
+        await this.db.delete(termRelationships).where(
+          (0, import_drizzle_orm4.and)(
+            (0, import_drizzle_orm4.eq)(termRelationships.objectId, objectId),
+            (0, import_drizzle_orm4.inArray)(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 = [(0, import_drizzle_orm4.eq)(termRelationships.objectId, objectId)];
+    if (taxonomy) {
+      conditions.push((0, import_drizzle_orm4.eq)(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,
+      (0, import_drizzle_orm4.eq)(termRelationships.termTaxonomyId, termTaxonomy.termTaxonomyId)
+    ).innerJoin(terms, (0, import_drizzle_orm4.eq)(termTaxonomy.termId, terms.termId)).where((0, import_drizzle_orm4.and)(...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((0, import_drizzle_orm4.eq)(termRelationships.termTaxonomyId, term.termTaxonomyId));
+    await this.db.delete(termTaxonomy).where((0, import_drizzle_orm4.eq)(termTaxonomy.termTaxonomyId, term.termTaxonomyId));
+    const otherUsages = await this.db.select({ termTaxonomyId: termTaxonomy.termTaxonomyId }).from(termTaxonomy).where((0, import_drizzle_orm4.eq)(termTaxonomy.termId, termId)).limit(1);
+    if (otherUsages.length === 0) {
+      await this.db.delete(terms).where((0, import_drizzle_orm4.eq)(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: import_drizzle_orm4.sql`count(*)::int` }).from(termRelationships).where((0, import_drizzle_orm4.eq)(termRelationships.termTaxonomyId, ttId));
+      await this.db.update(termTaxonomy).set({ count: result.count }).where((0, import_drizzle_orm4.eq)(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 = [(0, import_drizzle_orm4.eq)(terms.slug, candidate)];
+      if (excludeId !== void 0) {
+        conditions.push(import_drizzle_orm4.sql`${terms.termId} != ${excludeId}`);
+      }
+      const existing = await this.db.select({ termId: terms.termId }).from(terms).where((0, import_drizzle_orm4.and)(...conditions)).limit(1);
+      if (existing.length === 0) return candidate;
+      candidate = `${slug}-${suffix}`;
+      suffix++;
+    }
+  }
+};
+
+// src/repositories/revision-repository.ts
+var import_drizzle_orm5 = require("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((0, import_drizzle_orm5.and)((0, import_drizzle_orm5.eq)(posts.postParent, postId), (0, import_drizzle_orm5.eq)(posts.postType, "revision"))).orderBy((0, import_drizzle_orm5.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((0, import_drizzle_orm5.and)((0, import_drizzle_orm5.eq)(posts.id, revisionId), (0, import_drizzle_orm5.eq)(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((0, import_drizzle_orm5.eq)(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(
+      (0, import_drizzle_orm5.and)(
+        import_drizzle_orm5.sql`${posts.id} IN (${import_drizzle_orm5.sql.join(
+          idsToDelete.map((id) => import_drizzle_orm5.sql`${id}`),
+          import_drizzle_orm5.sql`, `
+        )})`,
+        (0, import_drizzle_orm5.eq)(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: import_drizzle_orm5.sql`count(*)::int` }).from(posts).where((0, import_drizzle_orm5.and)((0, import_drizzle_orm5.eq)(posts.postParent, postId), (0, import_drizzle_orm5.eq)(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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MetaRepository,
+  ObjectCache,
+  OptionsRepository,
+  PostRepository,
+  RevisionRepository,
+  TaxonomyRepository,
+  commentmeta,
+  comments,
+  createConnection,
+  links,
+  options,
+  postmeta,
+  posts,
+  scheduledEvents,
+  sessions,
+  termRelationships,
+  termTaxonomy,
+  termmeta,
+  terms,
+  usermeta,
+  users
+});
+//# sourceMappingURL=index.cjs.map