opacacms 0.2.0 → 0.3.0

package/dist/{chunk-esrg9qj0.js → chunk-5422w4eq.js}

@@ -3,20 +3,23 @@ import {
   flattenPayload,
   pushSchema,
   unflattenRow
-} from "./chunk-dykn5hr6.js";
+} from "./chunk-j8js1y0h.js";
 import {
   BaseDatabaseAdapter
 } from "./chunk-s8mqwnm1.js";
+import {
+  requestContext
+} from "./chunk-q5sb5dcr.js";
 import {
   getRelationalFields,
   toSnakeCase
 } from "./chunk-qxt9vge8.js";
 import {
   logger
-} from "./chunk-t0zg026p.js";
+} from "./chunk-jq1drsen.js";
 import {
   __require
-} from "./chunk-8sqjbsgt.js";
+} from "./chunk-6bywt602.js";
 
 // src/db/postgres.ts
 import fs from "node:fs/promises";
@@ -24,11 +27,9 @@ import path from "node:path";
 import {
   CompiledQuery,
   FileMigrationProvider,
-  Kysely,
   Migrator,
   PostgresDialect
 } from "kysely";
-import postgres from "postgres";
 class PostgresAdapter extends BaseDatabaseAdapter {
   name = "postgres";
   _rawDb = null;
@@ -43,6 +44,8 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     return this._rawDb;
   }
   get db() {
+    if (!this._db)
+      throw new Error("Database not connected. Call connect() first.");
     return this._db;
   }
   constructor(config, options) {
@@ -55,6 +58,7 @@ class PostgresAdapter extends BaseDatabaseAdapter {
   async connect() {
     if (this._rawDb)
       return;
+    const { default: postgres } = await import("postgres");
     if (typeof this.config === "string") {
       this._rawDb = postgres(this.config);
     } else {
@@ -67,7 +71,8 @@ class PostgresAdapter extends BaseDatabaseAdapter {
         ssl: this.config.ssl
       });
     }
-    this._db = new Kysely({
+    const { createOpacaKysely } = await import("./chunk-sqsfk9p4.js");
+    this._db = createOpacaKysely({
       dialect: new PostgresDialect({
         pool: {
           connect: async () => {
@@ -80,29 +85,32 @@ class PostgresAdapter extends BaseDatabaseAdapter {
           end: async () => {},
           on: () => {}
         }
-      })
+      }),
+      config: {
+        collections: this._collections,
+        globals: this._globals,
+        db: { name: "postgres" }
+      }
     });
   }
   async disconnect() {
     if (this._db)
-      await this._db.destroy();
+      await this.db.destroy();
     if (this._rawDb)
       await this._rawDb.end();
     this._db = null;
     this._rawDb = null;
   }
   async unsafe(query, params) {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
     const compiled = CompiledQuery.raw(query, params || []);
-    const result = await this._db.executeQuery(compiled);
+    const result = await this.db.executeQuery(compiled);
     return result.rows;
   }
   async count(collection, query) {
-    if (!this._db)
-      throw new Error("DB not connected");
     const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count"));
+    let qb = this.db.selectFrom(tableName).select((eb) => eb.fn.count("id").as("count"));
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
     }
@@ -110,10 +118,10 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     return Number(result?.count || 0);
   }
   async create(collection, data) {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       const colDef = this._collections.find((c) => c.slug === collection);
       const jsonFields = colDef?.fields.filter((f) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized)).map((f) => f.name) || [];
       const flatData = flattenPayload(data, "", jsonFields);
@@ -130,15 +138,6 @@ class PostgresAdapter extends BaseDatabaseAdapter {
           delete flatData[key];
         }
       }
-      if (!flatData.id)
-        flatData.id = crypto.randomUUID();
-      const now = new Date().toISOString();
-      const createdKey = toSnakeCase("createdAt");
-      const updatedKey = toSnakeCase("updatedAt");
-      if (!flatData[createdKey])
-        flatData[createdKey] = now;
-      if (!flatData[updatedKey])
-        flatData[updatedKey] = now;
       await tx.insertInto(tableName).values(flatData).execute();
       for (const [key, values] of Object.entries(hasManyData)) {
         const joinTableName = `${tableName}_${toSnakeCase(key)}_relations`.toLowerCase();
@@ -172,7 +171,7 @@ class PostgresAdapter extends BaseDatabaseAdapter {
   }
   async findOne(collection, query, tx) {
     const tableName = toSnakeCase(collection);
-    const executor = tx || this._db;
+    const executor = tx || this.db;
     if (!executor)
       throw new Error("DB not connected");
     let qb = executor.selectFrom(tableName).selectAll();
@@ -185,7 +184,7 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     const unflattened = unflattenRow(row);
     const colDef = this._collections.find((c) => c.slug === collection);
     if (colDef) {
-      const { getRelationalFields: getRelationalFields2, toSnakeCase: toSnakeCase2 } = await import("./chunk-526a3gqx.js");
+      const { getRelationalFields: getRelationalFields2, toSnakeCase: toSnakeCase2 } = await import("./chunk-fnsf1dfm.js");
       const relationalFields = getRelationalFields2(colDef.fields);
       for (const field of relationalFields) {
         if (!field.name)
@@ -236,14 +235,22 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     return unflattened;
   }
   async find(collection, query, options) {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
     const page = options?.page || 1;
     const limit = options?.limit || 10;
     const offset = (page - 1) * limit;
+    const cursorColumn = options?.cursorColumn || "id";
     const total = await this.count(collection, query);
     const tableName = toSnakeCase(collection);
-    let qb = this._db.selectFrom(tableName).selectAll().limit(limit).offset(offset);
+    let qb = this.db.selectFrom(tableName).selectAll().limit(limit);
+    if (options?.after) {
+      qb = qb.where(cursorColumn, ">", options.after);
+    } else if (options?.before) {
+      qb = qb.where(cursorColumn, "<", options.before);
+    } else {
+      qb = qb.offset(offset);
+    }
     if (query && Object.keys(query).length > 0) {
       qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
     }
@@ -253,11 +260,13 @@ class PostgresAdapter extends BaseDatabaseAdapter {
         qb = qb.orderBy(col, dir === "desc" ? "desc" : "asc");
       }
     } else {
-      qb = qb.orderBy("created_at", "desc");
+      qb = qb.orderBy(cursorColumn, "desc");
     }
     const rows = await qb.execute();
     if (rows.length === 0) {
       const totalPages2 = Math.ceil(total / limit);
+      const afterAnchor = options?.after;
+      const beforeAnchor = options?.before;
       return {
         docs: [],
         totalDocs: total,
@@ -265,10 +274,12 @@ class PostgresAdapter extends BaseDatabaseAdapter {
         totalPages: totalPages2,
         page,
         pagingCounter: offset + 1,
-        hasNextPage: page * limit < total,
-        hasPrevPage: page > 1,
-        prevPage: page > 1 ? page - 1 : null,
-        nextPage: page < totalPages2 ? page + 1 : null
+        hasNextPage: false,
+        hasPrevPage: !!afterAnchor || page > 1,
+        prevPage: null,
+        nextPage: null,
+        nextCursor: null,
+        prevCursor: afterAnchor ? afterAnchor : null
       };
     }
     const rowIds = rows.map((r) => r.id);
@@ -283,7 +294,7 @@ class PostgresAdapter extends BaseDatabaseAdapter {
         if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
           const joinTableName = `${toSnakeCase(collection)}_${snakeName}_relations`.toLowerCase();
           try {
-            const allRelations = await this._db.selectFrom(joinTableName).selectAll().where("source_id", "in", rowIds).orderBy("order", "asc").execute();
+            const allRelations = await this.db.selectFrom(joinTableName).selectAll().where("source_id", "in", rowIds).orderBy("order", "asc").execute();
             const relationsBySource = allRelations.reduce((acc, r) => {
               if (!acc[r.source_id])
                 acc[r.source_id] = [];
@@ -307,7 +318,7 @@ class PostgresAdapter extends BaseDatabaseAdapter {
           for (const b of field.blocks) {
             const blockTableName = `${collection}_${snakeName}_${toSnakeCase(b.slug)}`.toLowerCase();
             try {
-              const allBlocks = await this._db.selectFrom(blockTableName).selectAll().where("_parent_id", "in", rowIds).execute();
+              const allBlocks = await this.db.selectFrom(blockTableName).selectAll().where("_parent_id", "in", rowIds).execute();
               for (const blk of allBlocks) {
                 const uf = unflattenRow(blk);
                 uf.blockType = blk.block_type;
@@ -346,15 +357,17 @@ class PostgresAdapter extends BaseDatabaseAdapter {
       page,
       pagingCounter: offset + 1,
       hasNextPage: page * limit < total,
-      hasPrevPage: page > 1,
+      hasPrevPage: page > 1 || !!options?.after || !!options?.before,
       prevPage: page > 1 ? page - 1 : null,
-      nextPage: page < totalPages ? page + 1 : null
+      nextPage: page < totalPages ? page + 1 : null,
+      nextCursor: docs.length > 0 ? docs[docs.length - 1][cursorColumn] : null,
+      prevCursor: docs.length > 0 && (page > 1 || !!options?.after || !!options?.before) ? docs[0][cursorColumn] : null
     };
   }
   async update(collection, query, data) {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let normalizedQuery = query;
       if (typeof query !== "object" || query === null) {
         normalizedQuery = { id: query };
@@ -362,6 +375,9 @@ class PostgresAdapter extends BaseDatabaseAdapter {
       const current = await this.findOne(collection, normalizedQuery, tx);
       if (!current)
         throw new Error("Document not found");
+      const store = requestContext.getStore();
+      if (store)
+        store.previousData = current;
       const colDef = this._collections.find((c) => c.slug === collection);
       const jsonFields = colDef?.fields.filter((f) => f.name && (["richtext", "json", "file"].includes(f.type) || f.localized)).map((f) => f.name) || [];
       const flatData = flattenPayload(data, "", jsonFields);
@@ -424,10 +440,10 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     });
   }
   async updateMany(collection, query, data) {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let qb = tx.updateTable(tableName);
       if (query && Object.keys(query).length > 0) {
         qb = qb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -447,7 +463,7 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     });
   }
   async delete(collection, query) {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
     let normalizedQuery = query;
     if (typeof query !== "object" || query === null) {
@@ -457,7 +473,7 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     if (!current)
       return false;
     const tableName = toSnakeCase(collection);
-    await this._db.transaction().execute(async (tx) => {
+    await this.db.transaction().execute(async (tx) => {
       const colDef = this._collections.find((c) => c.slug === collection);
       if (colDef) {
         for (const field of colDef.fields) {
@@ -482,10 +498,10 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     return true;
   }
   async deleteMany(collection, query) {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
     const tableName = toSnakeCase(collection);
-    return this._db.transaction().execute(async (tx) => {
+    return this.db.transaction().execute(async (tx) => {
       let selectQb = tx.selectFrom(tableName).select("id");
       if (query && Object.keys(query).length > 0) {
         selectQb = selectQb.where((eb) => buildKyselyWhere(eb, query) || eb.val(true));
@@ -518,14 +534,14 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     });
   }
   async findGlobal(slug) {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
     const tableName = toSnakeCase(slug);
-    const row = await this._db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
+    const row = await this.db.selectFrom(tableName).selectAll().limit(1).executeTakeFirst();
     return row ? unflattenRow(row) : null;
   }
   async updateGlobal(slug, data) {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
     const tableName = toSnakeCase(slug);
     const existing = await this.findGlobal(slug);
@@ -538,17 +554,17 @@ class PostgresAdapter extends BaseDatabaseAdapter {
       if (!flatData.id)
         flatData.id = "global";
       flatData[toSnakeCase("createdAt")] = now;
-      await this._db.insertInto(tableName).values(flatData).execute();
+      await this.db.insertInto(tableName).values(flatData).execute();
     } else {
-      await this._db.updateTable(tableName).set(flatData).where("id", "=", existing.id).execute();
+      await this.db.updateTable(tableName).set(flatData).where("id", "=", existing.id).execute();
     }
     return this.findGlobal(slug);
   }
   async runMigrations() {
-    if (!this._db)
+    if (!this.db)
       throw new Error("DB not connected");
     const migrator = new Migrator({
-      db: this._db,
+      db: this.db,
       provider: new FileMigrationProvider({
         fs,
         path,
@@ -568,11 +584,11 @@ class PostgresAdapter extends BaseDatabaseAdapter {
     }
   }
   async migrate(collections, globals = []) {
-    const { getSystemCollections } = await import("./chunk-3rdhbedb.js");
+    const { getSystemCollections } = await import("./chunk-adq2b75c.js");
     this._collections = [...getSystemCollections(), ...collections];
     this._globals = globals;
     if (this.push && this._db) {
-      await pushSchema(this._db, "postgres", collections, globals, {
+      await pushSchema(this.db, "postgres", collections, globals, {
         pushDestructive: this.pushDestructive
       });
     }

package/dist/chunk-56n342hs.js

@@ -0,0 +1,95 @@
+import {
+  require_picocolors
+} from "./chunk-rwqwsanx.js";
+import {
+  Gt,
+  R,
+  Vt,
+  Wt,
+  be
+} from "./chunk-ec4jhybj.js";
+import {
+  loadConfig,
+  resolveConfigPath
+} from "./chunk-majsbncm.js";
+import {
+  defineCommand
+} from "./chunk-1qm0m8r8.js";
+import {
+  __toESM
+} from "./chunk-6bywt602.js";
+
+// src/cli/commands/doctor.ts
+import fs from "node:fs";
+var import_picocolors = __toESM(require_picocolors(), 1);
+var doctor_default = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Diagnose your OpacaCMS project configuration and database connection"
+  },
+  args: {
+    config: {
+      type: "string",
+      alias: "c",
+      description: "Path to the OpacaCMS configuration file"
+    }
+  },
+  async run({ args }) {
+    console.log();
+    Wt(import_picocolors.default.bgMagenta(import_picocolors.default.white(" OpacaCMS Doctor ")));
+    const s = be();
+    s.start("Locating configuration file...");
+    let configPath;
+    try {
+      configPath = resolveConfigPath(args.config);
+      s.stop(`Config found at ${import_picocolors.default.green(configPath)}`);
+    } catch (err) {
+      s.stop(import_picocolors.default.red("Config file not found."));
+      R.error("Could not find opacacms.config.ts or similar.");
+      Gt(import_picocolors.default.red("Diagnosis failed."));
+      process.exit(1);
+    }
+    s.start("Loading configuration...");
+    let opaca;
+    try {
+      opaca = await loadConfig(configPath);
+      s.stop(`Configuration loaded successfully. App Name: ${import_picocolors.default.cyan(opaca.appName || "Unknown")}`);
+    } catch (err) {
+      s.stop(import_picocolors.default.red("Failed to load configuration."));
+      R.error(err.message);
+      Gt(import_picocolors.default.red("Diagnosis failed."));
+      process.exit(1);
+    }
+    s.start("Verifying database connection...");
+    try {
+      if (!opaca.db)
+        throw new Error("No database configured in config.db");
+      const tables = await opaca.db.kysely.introspection.getTables();
+      s.stop(`Database connected successfully. Found ${import_picocolors.default.green(tables.length)} tables.`);
+    } catch (err) {
+      s.stop(import_picocolors.default.red("Database connection failed."));
+      R.error(err.message);
+    }
+    s.start("Checking dependencies...");
+    try {
+      const pkgPath = `${process.cwd()}/package.json`;
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (!deps.opacacms) {
+          R.warn(import_picocolors.default.yellow("opacacms is missing from package.json"));
+        }
+        s.stop(`Dependencies checked.`);
+      } else {
+        s.stop(import_picocolors.default.yellow("package.json not found."));
+      }
+    } catch (err) {
+      s.stop(import_picocolors.default.red("Error checking dependencies."));
+    }
+    Vt(`Everything seems to be in order! Run \`opacacms dev\` to start.`, "Diagnosis Complete");
+    Gt("Doctor out.");
+  }
+});
+export {
+  doctor_default as default
+};

package/dist/chunk-5b8r0v8c.js

@@ -0,0 +1,47 @@
+// src/utils/string.ts
+function sanitizeGraphQLName(name) {
+  return name.replace(/[^_a-zA-Z0-9]/g, "_");
+}
+function getRandomMigrationName() {
+  const adjectives = [
+    "vibrant",
+    "snarky",
+    "brave",
+    "swift",
+    "silent",
+    "funky",
+    "mystic",
+    "loyal",
+    "nimble",
+    "eager",
+    "wild",
+    "chill",
+    "golden",
+    "magic",
+    "smart",
+    "fierce"
+  ];
+  const nouns = [
+    "vulture",
+    "badger",
+    "falcon",
+    "otter",
+    "lynx",
+    "panda",
+    "fox",
+    "lemur",
+    "cobra",
+    "whale",
+    "eagle",
+    "tiger",
+    "koala",
+    "bison",
+    "raven",
+    "shark"
+  ];
+  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
+  const noun = nouns[Math.floor(Math.random() * nouns.length)];
+  return `${adj}_${noun}`;
+}
+
+export { sanitizeGraphQLName, getRandomMigrationName };