@rankmyseo/storage 0.1.0

package/dist/index.cjs

@@ -0,0 +1,641 @@
+"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, desc) => {
+  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: !(desc = __getOwnPropDesc(from, key)) || desc.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, {
+  createSqliteStore: () => createSqliteStore,
+  createStore: () => createStore
+});
+module.exports = __toCommonJS(index_exports);
+var import_server_only3 = require("server-only");
+
+// src/factory.ts
+var import_server_only2 = require("server-only");
+
+// src/sqlite-store.ts
+var import_server_only = require("server-only");
+var import_node_crypto = require("crypto");
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_better_sqlite32 = require("drizzle-orm/better-sqlite3");
+var import_drizzle_orm = require("drizzle-orm");
+
+// src/schema/sqlite.ts
+var import_sqlite_core = require("drizzle-orm/sqlite-core");
+var projects = (0, import_sqlite_core.sqliteTable)("rms_projects", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  tenantId: (0, import_sqlite_core.text)("tenant_id").notNull(),
+  name: (0, import_sqlite_core.text)("name").notNull(),
+  domain: (0, import_sqlite_core.text)("domain").notNull(),
+  createdAt: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+  updatedAt: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }).notNull()
+});
+var keywords = (0, import_sqlite_core.sqliteTable)("rms_keywords", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  tenantId: (0, import_sqlite_core.text)("tenant_id").notNull(),
+  projectId: (0, import_sqlite_core.text)("project_id").notNull(),
+  text: (0, import_sqlite_core.text)("text").notNull(),
+  country: (0, import_sqlite_core.text)("country").notNull(),
+  device: (0, import_sqlite_core.text)("device").notNull(),
+  tags: (0, import_sqlite_core.text)("tags").notNull(),
+  createdAt: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull()
+});
+var rankSnapshots = (0, import_sqlite_core.sqliteTable)("rms_rank_snapshots", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  tenantId: (0, import_sqlite_core.text)("tenant_id").notNull(),
+  projectId: (0, import_sqlite_core.text)("project_id").notNull(),
+  keywordId: (0, import_sqlite_core.text)("keyword_id").notNull(),
+  position: (0, import_sqlite_core.integer)("position"),
+  url: (0, import_sqlite_core.text)("url"),
+  source: (0, import_sqlite_core.text)("source").notNull(),
+  device: (0, import_sqlite_core.text)("device").notNull(),
+  country: (0, import_sqlite_core.text)("country").notNull(),
+  capturedAt: (0, import_sqlite_core.integer)("captured_at", { mode: "timestamp_ms" }).notNull(),
+  serpFeatures: (0, import_sqlite_core.text)("serp_features")
+});
+var audits = (0, import_sqlite_core.sqliteTable)("rms_audits", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  tenantId: (0, import_sqlite_core.text)("tenant_id").notNull(),
+  projectId: (0, import_sqlite_core.text)("project_id").notNull(),
+  url: (0, import_sqlite_core.text)("url").notNull(),
+  score: (0, import_sqlite_core.integer)("score").notNull(),
+  checks: (0, import_sqlite_core.text)("checks").notNull().default("[]"),
+  createdAt: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull()
+});
+var reports = (0, import_sqlite_core.sqliteTable)("rms_reports", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  tenantId: (0, import_sqlite_core.text)("tenant_id").notNull(),
+  projectId: (0, import_sqlite_core.text)("project_id").notNull(),
+  title: (0, import_sqlite_core.text)("title").notNull(),
+  from: (0, import_sqlite_core.integer)("from", { mode: "timestamp_ms" }).notNull(),
+  to: (0, import_sqlite_core.integer)("to", { mode: "timestamp_ms" }).notNull(),
+  summary: (0, import_sqlite_core.text)("summary"),
+  createdAt: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull()
+});
+var dashboardConfigs = (0, import_sqlite_core.sqliteTable)("rms_dashboard_configs", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  tenantId: (0, import_sqlite_core.text)("tenant_id").notNull(),
+  projectId: (0, import_sqlite_core.text)("project_id").notNull(),
+  widgets: (0, import_sqlite_core.text)("widgets").notNull(),
+  updatedAt: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }).notNull()
+});
+var blogPosts = (0, import_sqlite_core.sqliteTable)("rms_blog_posts", {
+  id: (0, import_sqlite_core.text)("id").primaryKey(),
+  tenantId: (0, import_sqlite_core.text)("tenant_id").notNull(),
+  projectId: (0, import_sqlite_core.text)("project_id").notNull(),
+  title: (0, import_sqlite_core.text)("title").notNull(),
+  slug: (0, import_sqlite_core.text)("slug").notNull(),
+  content: (0, import_sqlite_core.text)("content").notNull().default(""),
+  targetKeyword: (0, import_sqlite_core.text)("target_keyword").notNull().default(""),
+  intent: (0, import_sqlite_core.text)("intent").notNull().default("informational"),
+  metaTitle: (0, import_sqlite_core.text)("meta_title").notNull().default(""),
+  metaDescription: (0, import_sqlite_core.text)("meta_description").notNull().default(""),
+  status: (0, import_sqlite_core.text)("status").notNull().default("draft"),
+  createdAt: (0, import_sqlite_core.integer)("created_at", { mode: "timestamp_ms" }).notNull(),
+  updatedAt: (0, import_sqlite_core.integer)("updated_at", { mode: "timestamp_ms" }).notNull()
+});
+var sqliteSchema = {
+  projects,
+  keywords,
+  rankSnapshots,
+  audits,
+  reports,
+  dashboardConfigs,
+  blogPosts
+};
+
+// src/sqlite-store.ts
+function mapBlogRow(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    projectId: row.projectId,
+    title: row.title,
+    slug: row.slug,
+    content: row.content,
+    targetKeyword: row.targetKeyword,
+    intent: row.intent,
+    metaTitle: row.metaTitle,
+    metaDescription: row.metaDescription,
+    status: row.status,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function parseChecks(raw) {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function parseSummary(raw) {
+  if (!raw) return void 0;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function mapAuditRow(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    projectId: row.projectId,
+    url: row.url,
+    score: row.score,
+    checks: parseChecks(row.checks),
+    createdAt: row.createdAt
+  };
+}
+function mapReportRow(row) {
+  return {
+    id: row.id,
+    tenantId: row.tenantId,
+    projectId: row.projectId,
+    title: row.title,
+    from: row.from,
+    to: row.to,
+    summary: parseSummary(row.summary),
+    createdAt: row.createdAt
+  };
+}
+function parseTags(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((t) => typeof t === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function migrate(sqlite) {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS rms_projects (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      domain TEXT NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS rms_keywords (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      text TEXT NOT NULL,
+      country TEXT NOT NULL,
+      device TEXT NOT NULL,
+      tags TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS rms_rank_snapshots (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      keyword_id TEXT NOT NULL,
+      position INTEGER,
+      url TEXT,
+      source TEXT NOT NULL,
+      device TEXT NOT NULL,
+      country TEXT NOT NULL,
+      captured_at INTEGER NOT NULL,
+      serp_features TEXT
+    );
+    CREATE TABLE IF NOT EXISTS rms_audits (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      url TEXT NOT NULL,
+      score INTEGER NOT NULL,
+      checks TEXT NOT NULL DEFAULT '[]',
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS rms_reports (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      "from" INTEGER NOT NULL,
+      "to" INTEGER NOT NULL,
+      summary TEXT,
+      created_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS rms_dashboard_configs (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      widgets TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS rms_blog_posts (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL,
+      project_id TEXT NOT NULL,
+      title TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      target_keyword TEXT NOT NULL DEFAULT '',
+      intent TEXT NOT NULL DEFAULT 'informational',
+      meta_title TEXT NOT NULL DEFAULT '',
+      meta_description TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'draft',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+  try {
+    sqlite.exec(`ALTER TABLE rms_audits ADD COLUMN checks TEXT NOT NULL DEFAULT '[]'`);
+  } catch {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE rms_reports ADD COLUMN summary TEXT`);
+  } catch {
+  }
+}
+function createSqliteStore(databasePath) {
+  const sqlite = new import_better_sqlite3.default(databasePath);
+  migrate(sqlite);
+  const db = (0, import_better_sqlite32.drizzle)(sqlite, { schema: sqliteSchema });
+  const keywordScopeWhere = (scope) => (0, import_drizzle_orm.and)(
+    (0, import_drizzle_orm.eq)(keywords.tenantId, scope.tenantId),
+    (0, import_drizzle_orm.eq)(keywords.projectId, scope.projectId)
+  );
+  return {
+    projects: {
+      async create(input) {
+        const now = /* @__PURE__ */ new Date();
+        const row = {
+          ...input,
+          createdAt: now,
+          updatedAt: now
+        };
+        db.insert(projects).values({
+          id: row.id,
+          tenantId: row.tenantId,
+          name: row.name,
+          domain: row.domain,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt
+        }).run();
+        return row;
+      },
+      async getById(scope, id) {
+        const rows = db.select().from(projects).where((0, import_drizzle_orm.and)((0, import_drizzle_orm.eq)(projects.tenantId, scope.tenantId), (0, import_drizzle_orm.eq)(projects.id, id))).all();
+        const row = rows[0];
+        if (!row) return void 0;
+        return {
+          id: row.id,
+          tenantId: row.tenantId,
+          name: row.name,
+          domain: row.domain,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt
+        };
+      },
+      async list(scope) {
+        return db.select().from(projects).where((0, import_drizzle_orm.eq)(projects.tenantId, scope.tenantId)).all().map((row) => ({
+          id: row.id,
+          tenantId: row.tenantId,
+          name: row.name,
+          domain: row.domain,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt
+        }));
+      }
+    },
+    keywords: {
+      async create(input) {
+        const row = {
+          id: (0, import_node_crypto.randomUUID)(),
+          ...input,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        db.insert(keywords).values({
+          id: row.id,
+          tenantId: row.tenantId,
+          projectId: row.projectId,
+          text: row.text,
+          country: row.country,
+          device: row.device,
+          tags: JSON.stringify(row.tags),
+          createdAt: row.createdAt
+        }).run();
+        return row;
+      },
+      async getById(scope, id) {
+        const rows = db.select().from(keywords).where((0, import_drizzle_orm.and)(keywordScopeWhere(scope), (0, import_drizzle_orm.eq)(keywords.id, id))).all();
+        const row = rows[0];
+        if (!row) return void 0;
+        return {
+          id: row.id,
+          tenantId: row.tenantId,
+          projectId: row.projectId,
+          text: row.text,
+          country: row.country,
+          device: row.device,
+          tags: parseTags(row.tags),
+          createdAt: row.createdAt
+        };
+      },
+      async list(scope) {
+        return db.select().from(keywords).where(keywordScopeWhere(scope)).all().map((row) => ({
+          id: row.id,
+          tenantId: row.tenantId,
+          projectId: row.projectId,
+          text: row.text,
+          country: row.country,
+          device: row.device,
+          tags: parseTags(row.tags),
+          createdAt: row.createdAt
+        }));
+      },
+      async delete(scope, id) {
+        const result = db.delete(keywords).where((0, import_drizzle_orm.and)(keywordScopeWhere(scope), (0, import_drizzle_orm.eq)(keywords.id, id))).run();
+        return result.changes > 0;
+      }
+    },
+    snapshots: {
+      async append(input) {
+        const row = {
+          id: (0, import_node_crypto.randomUUID)(),
+          ...input
+        };
+        db.insert(rankSnapshots).values({
+          id: row.id,
+          tenantId: row.tenantId,
+          projectId: row.projectId,
+          keywordId: row.keywordId,
+          position: row.position,
+          url: row.url,
+          source: row.source,
+          device: row.device,
+          country: row.country,
+          capturedAt: row.capturedAt,
+          serpFeatures: row.serpFeatures ? JSON.stringify(row.serpFeatures) : null
+        }).run();
+        return row;
+      },
+      async listByRange(query) {
+        const conditions = [
+          (0, import_drizzle_orm.eq)(rankSnapshots.tenantId, query.tenantId),
+          (0, import_drizzle_orm.eq)(rankSnapshots.projectId, query.projectId),
+          (0, import_drizzle_orm.gte)(rankSnapshots.capturedAt, query.from),
+          (0, import_drizzle_orm.lte)(rankSnapshots.capturedAt, query.to)
+        ];
+        if (query.keywordId) {
+          conditions.push((0, import_drizzle_orm.eq)(rankSnapshots.keywordId, query.keywordId));
+        }
+        return db.select().from(rankSnapshots).where((0, import_drizzle_orm.and)(...conditions)).all().map((row) => ({
+          id: row.id,
+          tenantId: row.tenantId,
+          projectId: row.projectId,
+          keywordId: row.keywordId,
+          position: row.position,
+          url: row.url,
+          source: row.source,
+          device: row.device,
+          country: row.country,
+          capturedAt: row.capturedAt,
+          serpFeatures: row.serpFeatures ? JSON.parse(row.serpFeatures) : void 0
+        }));
+      }
+    },
+    audits: {
+      async create(input) {
+        const row = { ...input, checks: input.checks ?? [], createdAt: /* @__PURE__ */ new Date() };
+        db.insert(audits).values({
+          id: row.id,
+          tenantId: row.tenantId,
+          projectId: row.projectId,
+          url: row.url,
+          score: row.score,
+          checks: JSON.stringify(row.checks),
+          createdAt: row.createdAt
+        }).run();
+        return row;
+      },
+      async getById(scope, id) {
+        const rows = db.select().from(audits).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(audits.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(audits.projectId, scope.projectId),
+            (0, import_drizzle_orm.eq)(audits.id, id)
+          )
+        ).all();
+        const row = rows[0];
+        if (!row) return void 0;
+        return mapAuditRow(row);
+      },
+      async list(scope) {
+        return db.select().from(audits).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(audits.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(audits.projectId, scope.projectId)
+          )
+        ).all().map(mapAuditRow);
+      }
+    },
+    reports: {
+      async create(input) {
+        const row = { ...input, createdAt: /* @__PURE__ */ new Date() };
+        db.insert(reports).values({
+          id: row.id,
+          tenantId: row.tenantId,
+          projectId: row.projectId,
+          title: row.title,
+          from: row.from,
+          to: row.to,
+          summary: row.summary ? JSON.stringify(row.summary) : null,
+          createdAt: row.createdAt
+        }).run();
+        return row;
+      },
+      async getById(scope, id) {
+        const rows = db.select().from(reports).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(reports.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(reports.projectId, scope.projectId),
+            (0, import_drizzle_orm.eq)(reports.id, id)
+          )
+        ).all();
+        const row = rows[0];
+        if (!row) return void 0;
+        return mapReportRow(row);
+      },
+      async list(scope) {
+        return db.select().from(reports).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(reports.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(reports.projectId, scope.projectId)
+          )
+        ).all().map(mapReportRow);
+      }
+    },
+    dashboard: {
+      async get(scope) {
+        const rows = db.select().from(dashboardConfigs).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(dashboardConfigs.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(dashboardConfigs.projectId, scope.projectId)
+          )
+        ).all();
+        const row = rows[0];
+        if (!row) return void 0;
+        return {
+          id: row.id,
+          tenantId: row.tenantId,
+          projectId: row.projectId,
+          widgets: JSON.parse(row.widgets),
+          updatedAt: row.updatedAt
+        };
+      },
+      async upsert(config) {
+        db.insert(dashboardConfigs).values({
+          id: config.id,
+          tenantId: config.tenantId,
+          projectId: config.projectId,
+          widgets: JSON.stringify(config.widgets),
+          updatedAt: config.updatedAt
+        }).onConflictDoUpdate({
+          target: dashboardConfigs.id,
+          set: {
+            widgets: JSON.stringify(config.widgets),
+            updatedAt: config.updatedAt
+          }
+        }).run();
+        return config;
+      }
+    },
+    blog: {
+      async create(input) {
+        const now = /* @__PURE__ */ new Date();
+        const row = { ...input, createdAt: now, updatedAt: now };
+        db.insert(blogPosts).values({
+          id: row.id,
+          tenantId: row.tenantId,
+          projectId: row.projectId,
+          title: row.title,
+          slug: row.slug,
+          content: row.content,
+          targetKeyword: row.targetKeyword,
+          intent: row.intent,
+          metaTitle: row.metaTitle,
+          metaDescription: row.metaDescription,
+          status: row.status,
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt
+        }).run();
+        return row;
+      },
+      async getById(scope, id) {
+        const rows = db.select().from(blogPosts).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(blogPosts.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(blogPosts.projectId, scope.projectId),
+            (0, import_drizzle_orm.eq)(blogPosts.id, id)
+          )
+        ).all();
+        const row = rows[0];
+        return row ? mapBlogRow(row) : void 0;
+      },
+      async list(scope) {
+        return db.select().from(blogPosts).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(blogPosts.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(blogPosts.projectId, scope.projectId)
+          )
+        ).all().map(mapBlogRow);
+      },
+      async update(scope, id, patch) {
+        const rows = db.select().from(blogPosts).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(blogPosts.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(blogPosts.projectId, scope.projectId),
+            (0, import_drizzle_orm.eq)(blogPosts.id, id)
+          )
+        ).all();
+        const existing = rows[0];
+        if (!existing) return void 0;
+        const merged = mapBlogRow(existing);
+        const next = {
+          ...merged,
+          ...patch,
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        db.update(blogPosts).set({
+          title: next.title,
+          slug: next.slug,
+          content: next.content,
+          targetKeyword: next.targetKeyword,
+          intent: next.intent,
+          metaTitle: next.metaTitle,
+          metaDescription: next.metaDescription,
+          status: next.status,
+          updatedAt: next.updatedAt
+        }).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(blogPosts.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(blogPosts.projectId, scope.projectId),
+            (0, import_drizzle_orm.eq)(blogPosts.id, id)
+          )
+        ).run();
+        return next;
+      },
+      async delete(scope, id) {
+        const result = db.delete(blogPosts).where(
+          (0, import_drizzle_orm.and)(
+            (0, import_drizzle_orm.eq)(blogPosts.tenantId, scope.tenantId),
+            (0, import_drizzle_orm.eq)(blogPosts.projectId, scope.projectId),
+            (0, import_drizzle_orm.eq)(blogPosts.id, id)
+          )
+        ).run();
+        return result.changes > 0;
+      }
+    }
+  };
+}
+
+// src/factory.ts
+function createStore(databaseUrl) {
+  if (databaseUrl.startsWith("postgres") || databaseUrl.startsWith("mysql")) {
+    throw new Error(
+      "Postgres and MySQL adapters are not implemented in M0. Use sqlite:// or :memory:"
+    );
+  }
+  const path = databaseUrl.startsWith("sqlite://") ? databaseUrl.slice("sqlite://".length) : databaseUrl;
+  return createSqliteStore(path);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSqliteStore,
+  createStore
+});
+//# sourceMappingURL=index.cjs.map