opacacms 0.1.0

package/dist/chunk-j4d50hrx.js

@@ -0,0 +1,20 @@
+// src/admin/stores/ui.ts
+import { persistentAtom } from "@nanostores/persistent";
+import { atom } from "nanostores";
+var $toasts = atom([]);
+var $isSidebarCollapsed = persistentAtom("opaca-sidebar-collapsed", false, {
+  encode: JSON.stringify,
+  decode: JSON.parse
+});
+function toggleSidebar() {
+  $isSidebarCollapsed.set(!$isSidebarCollapsed.get());
+}
+function notify(message, type = "success") {
+  const id = Math.random().toString(36).substring(2, 9);
+  $toasts.set([...$toasts.get(), { id, message, type }]);
+}
+function clearToast(id) {
+  $toasts.set($toasts.get().filter((t) => t.id !== id));
+}
+
+export { $toasts, $isSidebarCollapsed, toggleSidebar, notify, clearToast };

package/dist/chunk-jwjk85ze.js

@@ -0,0 +1,15 @@
+import {
+  $isSidebarCollapsed,
+  $toasts,
+  clearToast,
+  notify,
+  toggleSidebar
+} from "./chunk-j4d50hrx.js";
+import"./chunk-8sqjbsgt.js";
+export {
+  toggleSidebar,
+  notify,
+  clearToast,
+  $toasts,
+  $isSidebarCollapsed
+};

package/dist/chunk-kwp83w8b.js

@@ -0,0 +1,250 @@
+import {
+  flattenFields,
+  mapFieldToPostgresType,
+  mapFieldToSQLiteType,
+  toSnakeCase
+} from "./chunk-cvdd4eqh.js";
+import"./chunk-8sqjbsgt.js";
+
+// src/db/kysely/migration-generator.ts
+function generateMigrationCode(collections, globals = [], dialect) {
+  const allSchemas = [...collections, ...globals];
+  const mapType = dialect === "postgres" ? mapFieldToPostgresType : mapFieldToSQLiteType;
+  const tsType = dialect === "postgres" ? "timestamp with time zone" : "text";
+  let upCode = "";
+  let downCode = "";
+  for (const collection of allSchemas) {
+    const slug = collection.slug;
+    const flattenedFields = flattenFields(collection.fields);
+    upCode += `  await db.schema.createTable('${slug}')
+`;
+    upCode += `    .addColumn('id', 'text', (col) => col.primaryKey())
+`;
+    for (const field of flattenedFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany)
+        continue;
+      const colName = toSnakeCase(field.name);
+      if (colName === "id")
+        continue;
+      const colType = mapType(field);
+      const constraints = [];
+      if (field.required)
+        constraints.push("notNull()");
+      if (field.unique)
+        constraints.push("unique()");
+      if (field.defaultValue !== undefined) {
+        let val = field.defaultValue;
+        if (typeof val === "string") {
+          val = `'${val}'`;
+        } else if (typeof val === "boolean") {
+          val = dialect === "sqlite" || dialect === "d1" ? val ? 1 : 0 : val;
+        }
+        constraints.push(`defaultTo(${val})`);
+      }
+      const constraintChain = constraints.length > 0 ? `.${constraints.join(".")}` : "";
+      upCode += `    .addColumn('${colName}', '${colType}', (col) => col${constraintChain})
+`;
+    }
+    const ts = collection.timestamps !== false;
+    if (ts) {
+      const config = typeof collection.timestamps === "object" ? collection.timestamps : {};
+      const createdField = toSnakeCase(config.createdAt || "createdAt");
+      const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+      upCode += `    .addColumn('${createdField}', '${tsType}', (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))
+`;
+      upCode += `    .addColumn('${updatedField}', '${tsType}', (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))
+`;
+    }
+    upCode += `    .execute();
+
+`;
+    downCode = `  await db.schema.dropTable('${slug}').execute();
+` + downCode;
+    for (const field of flattenedFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+        const colName = toSnakeCase(field.name);
+        const joinTableName = `${slug}_${colName}_relations`.toLowerCase();
+        upCode += `  await db.schema.createTable('${joinTableName}')
+`;
+        upCode += `    .addColumn('id', 'text', (col) => col.primaryKey())
+`;
+        upCode += `    .addColumn('source_id', 'text', (col) => col.notNull())
+`;
+        upCode += `    .addColumn('target_id', 'text', (col) => col.notNull())
+`;
+        upCode += `    .addColumn('order', 'integer', (col) => col.defaultTo(0))
+`;
+        upCode += `    .execute();
+
+`;
+        downCode = `  await db.schema.dropTable('${joinTableName}').execute();
+` + downCode;
+      }
+    }
+    for (const field of collection.fields) {
+      if (field.type === "blocks" && field.blocks && Array.isArray(field.blocks)) {
+        for (const block of field.blocks) {
+          const blockName = toSnakeCase(field.name);
+          const blockTableName = `${slug}_${blockName}_${block.slug}`.toLowerCase();
+          upCode += `  await db.schema.createTable('${blockTableName}')
+`;
+          upCode += `    .addColumn('id', 'text', (col) => col.primaryKey())
+`;
+          upCode += `    .addColumn('_parent_id', 'text', (col) => col.notNull())
+`;
+          upCode += `    .addColumn('_order', 'integer', (col) => col.defaultTo(0))
+`;
+          upCode += `    .addColumn('block_type', 'text', (col) => col.notNull())
+`;
+          const blockFlattened = flattenFields(block.fields);
+          for (const bField of blockFlattened) {
+            const bColName = toSnakeCase(bField.name);
+            if (bColName === "id")
+              continue;
+            const bColType = mapType(bField);
+            const bConstraints = [];
+            if (bField.required)
+              bConstraints.push("notNull()");
+            if (bField.unique)
+              bConstraints.push("unique()");
+            if (bField.defaultValue !== undefined) {
+              let bVal = bField.defaultValue;
+              if (typeof bVal === "string")
+                bVal = `'${bVal}'`;
+              else if (typeof bVal === "boolean")
+                bVal = dialect === "sqlite" || dialect === "d1" ? bVal ? 1 : 0 : bVal;
+              bConstraints.push(`defaultTo(${bVal})`);
+            }
+            const bConstraintChain = bConstraints.length > 0 ? `.${bConstraints.join(".")}` : "";
+            upCode += `    .addColumn('${bColName}', '${bColType}', (col) => col${bConstraintChain})
+`;
+          }
+          upCode += `    .addColumn('created_at', '${tsType}', (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))
+`;
+          upCode += `    .addColumn('updated_at', '${tsType}', (col) => col.defaultTo(sql\`CURRENT_TIMESTAMP\`))
+`;
+          upCode += `    .execute();
+
+`;
+          downCode = `  await db.schema.dropTable('${blockTableName}').execute();
+` + downCode;
+        }
+      }
+    }
+  }
+  return `import { Kysely, sql } from 'kysely';
+
+export async function up(db: Kysely<any>): Promise<void> {
+${upCode}}
+
+export async function down(db: Kysely<any>): Promise<void> {
+${downCode}}
+`;
+}
+function generateSQLCode(collections, globals = []) {
+  const allSchemas = [...collections, ...globals];
+  let sql = `-- OpacaCMS Auto-generated SQL Migration
+
+`;
+  for (const collection of allSchemas) {
+    const slug = collection.slug;
+    const flattenedFields = flattenFields(collection.fields);
+    sql += `CREATE TABLE IF NOT EXISTS "${slug}" (
+`;
+    sql += `  "id" TEXT PRIMARY KEY`;
+    for (const field of flattenedFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany)
+        continue;
+      const colName = toSnakeCase(field.name);
+      if (colName === "id")
+        continue;
+      const colType = mapFieldToSQLiteType(field);
+      sql += `,
+  "${colName}" ${colType.toUpperCase()}`;
+      if (field.required)
+        sql += " NOT NULL";
+      if (field.unique)
+        sql += " UNIQUE";
+      if (field.defaultValue !== undefined) {
+        let val = field.defaultValue;
+        if (typeof val === "string")
+          val = `'${val}'`;
+        else if (typeof val === "boolean")
+          val = val ? 1 : 0;
+        sql += ` DEFAULT ${val}`;
+      }
+    }
+    const ts = collection.timestamps !== false;
+    if (ts) {
+      const config = typeof collection.timestamps === "object" ? collection.timestamps : {};
+      const createdField = toSnakeCase(config.createdAt || "createdAt");
+      const updatedField = toSnakeCase(config.updatedAt || "updatedAt");
+      sql += `,
+  "${createdField}" TEXT DEFAULT CURRENT_TIMESTAMP`;
+      sql += `,
+  "${updatedField}" TEXT DEFAULT CURRENT_TIMESTAMP`;
+    }
+    sql += `
+);
+
+`;
+    for (const field of flattenedFields) {
+      if (field.type === "relationship" && "hasMany" in field && field.hasMany) {
+        const colName = toSnakeCase(field.name);
+        const joinTableName = `${slug}_${colName}_relations`.toLowerCase();
+        sql += `CREATE TABLE IF NOT EXISTS "${joinTableName}" (
+`;
+        sql += `  "id" TEXT PRIMARY KEY,
+`;
+        sql += `  "source_id" TEXT NOT NULL,
+`;
+        sql += `  "target_id" TEXT NOT NULL,
+`;
+        sql += `  "order" INTEGER DEFAULT 0
+`;
+        sql += `);
+
+`;
+      }
+    }
+    for (const field of collection.fields) {
+      if (field.type === "blocks" && field.blocks && Array.isArray(field.blocks)) {
+        for (const block of field.blocks) {
+          const blockName = toSnakeCase(field.name);
+          const blockTableName = `${slug}_${blockName}_${block.slug}`.toLowerCase();
+          sql += `CREATE TABLE IF NOT EXISTS "${blockTableName}" (
+`;
+          sql += `  "id" TEXT PRIMARY KEY,
+`;
+          sql += `  "_parent_id" TEXT NOT NULL,
+`;
+          sql += `  "_order" INTEGER DEFAULT 0,
+`;
+          sql += `  "block_type" TEXT NOT NULL`;
+          const blockFlattened = flattenFields(block.fields);
+          for (const bField of blockFlattened) {
+            const bColName = toSnakeCase(bField.name);
+            if (bColName === "id")
+              continue;
+            const bColType = mapFieldToSQLiteType(bField);
+            sql += `,
+  "${bColName}" ${bColType.toUpperCase()}`;
+          }
+          sql += `,
+  "created_at" TEXT DEFAULT CURRENT_TIMESTAMP,
+`;
+          sql += `  "updated_at" TEXT DEFAULT CURRENT_TIMESTAMP
+`;
+          sql += `);
+
+`;
+        }
+      }
+    }
+  }
+  return sql;
+}
+export {
+  generateSQLCode,
+  generateMigrationCode
+};

package/dist/chunk-s8mqwnm1.js

@@ -0,0 +1,14 @@
+// src/db/adapter.ts
+class BaseDatabaseAdapter {
+  get raw() {
+    return;
+  }
+  get db() {
+    return;
+  }
+  push;
+  pushDestructive;
+  migrationDir;
+}
+
+export { BaseDatabaseAdapter };

package/dist/chunk-srsac177.js

@@ -0,0 +1,85 @@
+import"./chunk-8sqjbsgt.js";
+
+// src/cli/commands/init.ts
+import fs from "node:fs";
+import { resolve } from "node:path";
+async function initCommand(target, example) {
+  console.log(`[OpacaCMS] Initializing new project in ./${target}...`);
+  if (example) {
+    console.log(`[OpacaCMS] Using example template: ${example}`);
+    let currentDir = resolve(import.meta.dirname);
+    let exampleDir = "";
+    const localExample = resolve(process.cwd(), "examples", example);
+    if (fs.existsSync(localExample)) {
+      exampleDir = localExample;
+    } else {
+      while (currentDir !== resolve(currentDir, "..")) {
+        const potential = resolve(currentDir, "examples", example);
+        if (fs.existsSync(potential)) {
+          exampleDir = potential;
+          break;
+        }
+        currentDir = resolve(currentDir, "..");
+      }
+    }
+    if (!exampleDir) {
+      console.error(`[OpacaCMS] Example ${example} not found.`);
+      process.exit(1);
+    }
+    fs.cpSync(exampleDir, resolve(process.cwd(), target), { recursive: true });
+    console.log(`[OpacaCMS] Copied example ${example} to ${target}!`);
+    return;
+  }
+  console.log(`[OpacaCMS] Generating default boilerplate...`);
+  fs.mkdirSync(resolve(process.cwd(), target), { recursive: true });
+  const configCode = `import { defineConfig } from 'opacacms';
+import { createSQLiteAdapter } from 'opacacms/db/sqlite';
+
+export default defineConfig({
+  appName: "My OpacaCMS App",
+  db: createSQLiteAdapter('local.db'),
+  collections: [
+    {
+      slug: 'posts',
+      fields: [
+        { name: 'title', type: 'text', required: true },
+        { name: 'content', type: 'text' }
+      ]
+    }
+  ]
+});
+`;
+  fs.writeFileSync(resolve(process.cwd(), target, "opacacms.config.ts"), configCode);
+  const serverCode = `import { Hono } from 'hono';
+import { createAPIRouter } from 'opacacms/server';
+import config from './opacacms.config';
+
+const app = new Hono();
+app.route('/api', createAPIRouter(config));
+
+export default app;
+`;
+  fs.writeFileSync(resolve(process.cwd(), target, "index.ts"), serverCode);
+  const pkgJson = {
+    name: target,
+    type: "module",
+    scripts: {
+      start: "bun run index.ts",
+      dev: "bun run --watch index.ts"
+    },
+    dependencies: {
+      opacacms: "latest",
+      hono: "^4.0.0"
+    }
+  };
+  fs.writeFileSync(resolve(process.cwd(), target, "package.json"), JSON.stringify(pkgJson, null, 2));
+  console.log(`[OpacaCMS] Project created successfully!`);
+  console.log(`
+cd ${target}`);
+  console.log(`bun install`);
+  console.log(`bun run dev
+`);
+}
+export {
+  initCommand
+};

package/dist/chunk-v521d72w.js

@@ -0,0 +1,10 @@
+import {
+  getSystemCollections,
+  init_system_schema
+} from "./chunk-ybbbqj63.js";
+import"./chunk-8sqjbsgt.js";
+init_system_schema();
+
+export {
+  getSystemCollections
+};

package/dist/chunk-xa7rjsn2.js

@@ -0,0 +1,20 @@
+import {
+  $isAuthPending,
+  $isAuthenticated,
+  $session,
+  $user,
+  login,
+  logout,
+  syncSession
+} from "./chunk-16vgcf3k.js";
+import"./chunk-j4d50hrx.js";
+import"./chunk-8sqjbsgt.js";
+export {
+  syncSession,
+  logout,
+  login,
+  $user,
+  $session,
+  $isAuthenticated,
+  $isAuthPending
+};

package/dist/chunk-xg35h5a3.js

@@ -0,0 +1,15 @@
+import {
+  flattenFields,
+  getRelationalFields,
+  mapFieldToPostgresType,
+  mapFieldToSQLiteType,
+  toSnakeCase
+} from "./chunk-cvdd4eqh.js";
+import"./chunk-8sqjbsgt.js";
+export {
+  toSnakeCase,
+  mapFieldToSQLiteType,
+  mapFieldToPostgresType,
+  getRelationalFields,
+  flattenFields
+};

package/dist/chunk-ybbbqj63.js

@@ -0,0 +1,130 @@
+import {
+  __esm,
+  __export
+} from "./chunk-8sqjbsgt.js";
+
+// src/db/system-schema.ts
+var exports_system_schema = {};
+__export(exports_system_schema, {
+  getSystemCollections: () => getSystemCollections
+});
+var getSystemCollections = () => [
+  {
+    slug: "_opaca_assets",
+    label: "Assets",
+    apiPath: "assets",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "key", type: "text", required: true },
+      { name: "filename", type: "text", required: true },
+      { name: "originalFilename", type: "text", required: true },
+      { name: "mimeType", type: "text", required: true },
+      { name: "filesize", type: "number", required: true },
+      { name: "bucket", type: "text", required: true },
+      { name: "folder", type: "text" },
+      { name: "altText", type: "text" },
+      { name: "caption", type: "text" },
+      { name: "uploadedBy", type: "text" }
+    ],
+    timestamps: true
+  },
+  {
+    slug: "_users",
+    apiPath: "users",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "name", type: "text", required: true },
+      { name: "email", type: "text", required: true, unique: true },
+      { name: "emailVerified", type: "boolean", required: true, defaultValue: false },
+      { name: "image", type: "text" },
+      { name: "role", type: "text" },
+      { name: "banned", type: "boolean" },
+      { name: "banReason", type: "text" },
+      { name: "banExpires", type: "date" }
+    ],
+    timestamps: true
+  },
+  {
+    slug: "_sessions",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "expiresAt", type: "date", required: true },
+      { name: "token", type: "text", required: true, unique: true },
+      { name: "ipAddress", type: "text" },
+      { name: "userAgent", type: "text" },
+      {
+        name: "userId",
+        type: "text",
+        required: true,
+        references: { table: "_users", column: "id", onDelete: "cascade" }
+      },
+      { name: "impersonatedBy", type: "text" }
+    ],
+    timestamps: true,
+    hidden: true
+  },
+  {
+    slug: "_accounts",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "accountId", type: "text", required: true },
+      { name: "providerId", type: "text", required: true },
+      {
+        name: "userId",
+        type: "text",
+        required: true,
+        references: { table: "_users", column: "id", onDelete: "cascade" }
+      },
+      { name: "accessToken", type: "text" },
+      { name: "refreshToken", type: "text" },
+      { name: "idToken", type: "text" },
+      { name: "accessTokenExpiresAt", type: "date" },
+      { name: "refreshTokenExpiresAt", type: "date" },
+      { name: "scope", type: "text" },
+      { name: "password", type: "text" }
+    ],
+    timestamps: true,
+    hidden: true
+  },
+  {
+    slug: "_verifications",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "identifier", type: "text", required: true },
+      { name: "value", type: "text", required: true },
+      { name: "expiresAt", type: "date", required: true }
+    ],
+    timestamps: true,
+    hidden: true
+  },
+  {
+    slug: "_api_keys",
+    fields: [
+      { name: "id", type: "text", required: true },
+      { name: "configId", type: "text", required: true },
+      { name: "name", type: "text" },
+      { name: "start", type: "text" },
+      { name: "prefix", type: "text" },
+      { name: "key", type: "text", required: true },
+      { name: "referenceId", type: "text", required: true },
+      { name: "refillInterval", type: "number" },
+      { name: "refillAmount", type: "number" },
+      { name: "lastRefillAt", type: "date" },
+      { name: "enabled", type: "boolean", required: true },
+      { name: "rateLimitEnabled", type: "boolean", required: true },
+      { name: "rateLimitTimeWindow", type: "number" },
+      { name: "rateLimitMax", type: "number" },
+      { name: "requestCount", type: "number", required: true },
+      { name: "remaining", type: "number" },
+      { name: "lastRequest", type: "date" },
+      { name: "expiresAt", type: "date" },
+      { name: "permissions", type: "text" },
+      { name: "metadata", type: "text" }
+    ],
+    timestamps: { createdAt: "createdAt", updatedAt: "updatedAt" },
+    hidden: true
+  }
+];
+var init_system_schema = () => {};
+
+export { getSystemCollections, exports_system_schema, init_system_schema };