@rimelight/cms 0.0.2 → 0.0.4

package/dist/schema/sqlite.mjs

@@ -0,0 +1,137 @@
+import { sql } from "drizzle-orm";
+import { index, integer, sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+//#region src/schema/sqlite.ts
+const pageTemplates = sqliteTable("page_templates", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	slug: text("slug").notNull().unique(),
+	title: text("title", { mode: "json" }).$type().notNull(),
+	description: text("description", { mode: "json" }).$type(),
+	pageType: text("page_type").$type().notNull(),
+	version: integer("version").default(1).notNull(),
+	allowedRoles: text("allowed_roles", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	rolePermissions: text("role_permissions", { mode: "json" }).$type().default(sql`'{"whoCanCreate":[],"whoCanEdit":[],"whoCanReview":[],"whoCanView":[]}'`).notNull(),
+	requiredPermission: text("required_permission"),
+	approvalRules: text("approval_rules", { mode: "json" }).$type().default(sql`'{"allowSelfApproval":true,"minApprovals":1}'`).notNull(),
+	defaultProperties: text("default_properties", { mode: "json" }).default(sql`'{}'`).notNull(),
+	initialBlocks: text("initial_blocks", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$onUpdate(() => /* @__PURE__ */ new Date())
+});
+const pageVersions = sqliteTable("page_versions", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	pageId: text("page_id").notNull(),
+	versionNumber: integer("version_number").notNull(),
+	status: text("status").$type().default("pending").notNull(),
+	slug: text("slug").notNull(),
+	type: text("type").$type().notNull(),
+	title: text("title", { mode: "json" }).$type().notNull(),
+	description: text("description", { mode: "json" }).$type(),
+	tags: text("tags", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	authorIds: text("author_ids", { mode: "json" }).$type().default(sql`'[]'`),
+	bylines: text("bylines", { mode: "json" }).$type().default(sql`'[]'`),
+	content: text("content", { mode: "json" }).$type().notNull(),
+	createdBy: text("created_by").notNull(),
+	approvedBy: text("approved_by", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	approvedAt: integer("approved_at", { mode: "timestamp" }),
+	changeSummary: text("change_summary"),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+}, (table) => [uniqueIndex("page_versions_page_id_version_idx").on(table.pageId, table.versionNumber)]);
+const pages = sqliteTable("pages", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	slug: text("slug").notNull(),
+	type: text("type").$type().notNull(),
+	templateId: text("template_id").references(() => pageTemplates.id, { onDelete: "set null" }),
+	templateVersion: integer("template_version").default(1).notNull(),
+	title: text("title", { mode: "json" }).$type().notNull(),
+	description: text("description", { mode: "json" }).$type(),
+	tags: text("tags", { mode: "json" }).$type().default(sql`'[]'`).notNull(),
+	authorIds: text("author_ids", { mode: "json" }).$type().default(sql`'[]'`),
+	bylines: text("bylines", { mode: "json" }).$type().default(sql`'[]'`),
+	content: text("content", { mode: "json" }).$type().notNull(),
+	publishedVersionId: text("published_version_id").references(() => pageVersions.id, { onDelete: "set null" }),
+	postedAt: integer("posted_at", { mode: "timestamp" }),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$onUpdate(() => /* @__PURE__ */ new Date()),
+	deletedAt: integer("deleted_at", { mode: "timestamp" })
+}, (table) => [uniqueIndex("pages_slug_active_unique_idx").on(table.slug).where(sql`deleted_at IS NULL`)]);
+const pageDrafts = sqliteTable("page_drafts", {
+	pageId: text("page_id").notNull().primaryKey().references(() => pages.id, { onDelete: "cascade" }),
+	content: text("content", { mode: "json" }).$type().notNull(),
+	updatedBy: text("updated_by").notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+});
+const pageDraftLocks = sqliteTable("page_draft_locks", {
+	pageId: text("page_id").notNull().primaryKey().references(() => pages.id, { onDelete: "cascade" }),
+	lockedByUserId: text("locked_by_user_id").notNull(),
+	lockedByUserName: text("locked_by_user_name").notNull(),
+	acquiredAt: integer("acquired_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	expiresAt: integer("expires_at", { mode: "timestamp" }).notNull()
+});
+const pageVersionApprovals = sqliteTable("page_version_approvals", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	versionId: text("version_id").notNull().references(() => pageVersions.id, { onDelete: "cascade" }),
+	userId: text("user_id").notNull(),
+	userRole: text("user_role").notNull(),
+	approvedAt: integer("approved_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+});
+const pageVersionComments = sqliteTable("page_version_comments", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	versionId: text("version_id").notNull().references(() => pageVersions.id, { onDelete: "cascade" }),
+	userId: text("user_id").notNull(),
+	userRole: text("user_role").notNull(),
+	content: text("content").notNull(),
+	blockId: text("block_id"),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+});
+const contentSearchIndex = sqliteTable("content_search_index", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	pageId: text("page_id").notNull().references(() => pages.id, { onDelete: "cascade" }),
+	locale: text("locale").notNull(),
+	titleText: text("title_text").notNull(),
+	contentText: text("content_text").notNull()
+}, (table) => [index("content_search_index_page_id_idx").on(table.pageId)]);
+const siteSettings = sqliteTable("site_settings", {
+	id: text("id").primaryKey().default("default"),
+	name: text("name").notNull(),
+	description: text("description").notNull(),
+	url: text("url").notNull(),
+	ogImage: text("og_image").notNull(),
+	author: text("author").notNull(),
+	email: text("email").notNull().default(""),
+	branding: text("branding", { mode: "json" }).$type().notNull(),
+	seo: text("seo", { mode: "json" }).$type().notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
+});
+const taxonomyTerms = sqliteTable("taxonomy_terms", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).notNull().primaryKey(),
+	taxonomy: text("taxonomy").notNull(),
+	slug: text("slug").notNull(),
+	label: text("label", { mode: "json" }).$type().notNull(),
+	description: text("description", { mode: "json" }).$type(),
+	parentId: text("parent_id").references(() => taxonomyTerms.id, { onDelete: "cascade" }),
+	displayOrder: integer("display_order").default(0).notNull(),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$onUpdate(() => /* @__PURE__ */ new Date())
+}, (table) => [uniqueIndex("taxonomy_terms_tax_slug_idx").on(table.taxonomy, table.slug)]);
+const pageTaxonomyTerms = sqliteTable("page_taxonomy_terms", {
+	pageId: text("page_id").notNull().references(() => pages.id, { onDelete: "cascade" }),
+	termId: text("term_id").notNull().references(() => taxonomyTerms.id, { onDelete: "cascade" }),
+	assignedAt: integer("assigned_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull()
+}, (table) => [uniqueIndex("page_taxonomy_terms_page_term_idx").on(table.pageId, table.termId)]);
+const bylines = sqliteTable("bylines", {
+	id: text("id").$defaultFn(() => crypto.randomUUID()).primaryKey(),
+	name: text("name").notNull(),
+	slug: text("slug").notNull(),
+	websiteUrl: text("website_url"),
+	bio: text("bio"),
+	avatar: text("avatar"),
+	userId: text("user_id"),
+	socials: text("socials", { mode: "json" }).$type().default(sql`'{}'`),
+	metadata: text("metadata", { mode: "json" }).$type().default(sql`'{}'`),
+	createdAt: integer("created_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	updatedAt: integer("updated_at", { mode: "timestamp" }).$defaultFn(() => /* @__PURE__ */ new Date()).notNull(),
+	deletedAt: integer("deleted_at", { mode: "timestamp" })
+}, (table) => [uniqueIndex("bylines_slug_idx").on(table.slug)]);
+//#endregion
+export { bylines, contentSearchIndex, pageDraftLocks, pageDrafts, pageTaxonomyTerms, pageTemplates, pageVersionApprovals, pageVersionComments, pageVersions, pages, siteSettings, taxonomyTerms };

package/dist/storage/index.d.mts

@@ -0,0 +1,59 @@
+//#region src/storage/index.d.ts
+interface StorageFile {
+  key: string;
+  name: string;
+  size: number;
+  mimeType: string;
+  uploadedAt: string;
+  url: string;
+  etag?: string;
+  customMetadata?: Record<string, string>;
+}
+interface StorageListResult {
+  files: StorageFile[];
+  truncated: boolean;
+  cursor?: string;
+}
+interface R2StorageOptions {
+  binding?: string | undefined;
+  publicUrl?: string | undefined;
+  prefix?: string | undefined;
+}
+interface StorageConfig {
+  provider: "r2" | "local" | "s3";
+  binding?: string | undefined;
+  publicUrl?: string | undefined;
+  prefix?: string | undefined;
+}
+interface StorageListOptions {
+  prefix?: string | undefined;
+  cursor?: string | undefined;
+  limit?: number | undefined;
+  publicUrl?: string | undefined;
+  apiBasePath?: string | undefined;
+}
+interface StorageUploadOptions {
+  key?: string | undefined;
+  prefix?: string | undefined;
+  publicUrl?: string | undefined;
+  apiBasePath?: string | undefined;
+}
+declare function r2(options?: R2StorageOptions): StorageConfig;
+/**
+ * Resolves Cloudflare R2 bucket instance from Cloudflare env or Astro locals.
+ */
+declare function getR2Bucket(locals?: any, bindingName?: string): Promise<any>;
+/**
+ * Lists files from R2 Bucket under configured prefix.
+ */
+declare function listR2Files(bucket: any, options?: StorageListOptions): Promise<StorageListResult>;
+/**
+ * Uploads a file buffer/stream into R2 Bucket.
+ */
+declare function uploadR2File(bucket: any, file: File, options?: StorageUploadOptions): Promise<StorageFile>;
+/**
+ * Deletes a file from R2 Bucket by key.
+ */
+declare function deleteR2File(bucket: any, key: string): Promise<boolean>;
+//#endregion
+export { R2StorageOptions, StorageConfig, StorageFile, StorageListOptions, StorageListResult, StorageUploadOptions, deleteR2File, getR2Bucket, listR2Files, r2, uploadR2File };

package/dist/storage/index.mjs

@@ -0,0 +1,133 @@
+//#region src/storage/index.ts
+function r2(options = {}) {
+	return {
+		provider: "r2",
+		binding: options.binding ?? "BLOB",
+		publicUrl: options.publicUrl,
+		prefix: options.prefix ?? "media/"
+	};
+}
+/**
+* Resolves Cloudflare R2 bucket instance from Cloudflare env or Astro locals.
+*/
+async function getR2Bucket(locals, bindingName = "BLOB") {
+	try {
+		const cf = await import("cloudflare:workers");
+		if (cf?.env && cf.env[bindingName]) return cf.env[bindingName];
+	} catch {}
+	if (locals) {
+		if (locals.runtime?.env && locals.runtime.env[bindingName]) return locals.runtime.env[bindingName];
+		if (locals.env && locals.env[bindingName]) return locals.env[bindingName];
+		if (locals[bindingName]) return locals[bindingName];
+	}
+	if (typeof process !== "undefined" && process.env && process.env[bindingName]) return process.env[bindingName];
+	return null;
+}
+/**
+* Lists files from R2 Bucket under configured prefix.
+*/
+async function listR2Files(bucket, options = {}) {
+	if (!bucket || typeof bucket.list !== "function") return {
+		files: [],
+		truncated: false
+	};
+	const prefix = options.prefix ?? "media/";
+	const limit = options.limit ?? 50;
+	const result = await bucket.list({
+		prefix,
+		cursor: options.cursor,
+		limit
+	});
+	return {
+		files: (result.objects || []).map((obj) => {
+			const rawKey = obj.key;
+			const name = rawKey.startsWith(prefix) ? rawKey.slice(prefix.length) : rawKey;
+			const cleanedName = name.includes("/") ? name.split("/").pop() : name;
+			const mimeType = obj.httpMetadata?.contentType || guessMimeType(rawKey);
+			let url = "";
+			if (options.publicUrl) url = `${options.publicUrl.endsWith("/") ? options.publicUrl.slice(0, -1) : options.publicUrl}/${rawKey}`;
+			else if (options.apiBasePath) url = `${options.apiBasePath.endsWith("/") ? options.apiBasePath.slice(0, -1) : options.apiBasePath}/${rawKey}`;
+			else url = `/cms/api/media/${rawKey}`;
+			return {
+				key: rawKey,
+				name: cleanedName,
+				size: obj.size,
+				mimeType,
+				uploadedAt: obj.uploaded ? new Date(obj.uploaded).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+				url,
+				etag: obj.etag,
+				customMetadata: obj.customMetadata
+			};
+		}),
+		truncated: result.truncated,
+		cursor: result.cursor
+	};
+}
+/**
+* Uploads a file buffer/stream into R2 Bucket.
+*/
+async function uploadR2File(bucket, file, options = {}) {
+	if (!bucket || typeof bucket.put !== "function") throw new Error("R2 bucket binding is not available in runtime environment.");
+	const prefix = options.prefix ?? "media/";
+	const timestamp = Date.now();
+	const safeName = file.name.replace(/[^a-zA-Z0-9._-]/g, "_");
+	const randomSuffix = Math.random().toString(36).substring(2, 8);
+	const key = options.key ?? `${prefix}${timestamp}-${randomSuffix}/${safeName}`;
+	const arrayBuffer = await file.arrayBuffer();
+	const r2Object = await bucket.put(key, arrayBuffer, {
+		httpMetadata: {
+			contentType: file.type || guessMimeType(safeName),
+			contentDisposition: `inline; filename="${safeName}"`
+		},
+		customMetadata: {
+			originalName: file.name,
+			uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	});
+	let url = "";
+	if (options.publicUrl) url = `${options.publicUrl.endsWith("/") ? options.publicUrl.slice(0, -1) : options.publicUrl}/${key}`;
+	else if (options.apiBasePath) url = `${options.apiBasePath.endsWith("/") ? options.apiBasePath.slice(0, -1) : options.apiBasePath}/${key}`;
+	else url = `/cms/api/media/${key}`;
+	return {
+		key,
+		name: safeName,
+		size: file.size,
+		mimeType: file.type || guessMimeType(safeName),
+		uploadedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		url,
+		etag: r2Object?.etag
+	};
+}
+/**
+* Deletes a file from R2 Bucket by key.
+*/
+async function deleteR2File(bucket, key) {
+	if (!bucket || typeof bucket.delete !== "function") throw new Error("R2 bucket binding is not available in runtime environment.");
+	await bucket.delete(key);
+	return true;
+}
+/**
+* MIME type guesser fallback.
+*/
+function guessMimeType(filename) {
+	switch (filename.split(".").pop()?.toLowerCase()) {
+		case "jpg":
+		case "jpeg": return "image/jpeg";
+		case "png": return "image/png";
+		case "webp": return "image/webp";
+		case "gif": return "image/gif";
+		case "svg": return "image/svg+xml";
+		case "avif": return "image/avif";
+		case "mp4": return "video/mp4";
+		case "webm": return "video/webm";
+		case "mp3": return "audio/mpeg";
+		case "wav": return "audio/wav";
+		case "pdf": return "application/pdf";
+		case "json": return "application/json";
+		case "txt": return "text/plain";
+		case "zip": return "application/zip";
+		default: return "application/octet-stream";
+	}
+}
+//#endregion
+export { deleteR2File, getR2Bucket, listR2Files, r2, uploadR2File };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimelight/cms",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "private": false,
   "description": "Rimelight Entertainment's Content Management System Package",
   "homepage": "https://rimelight.com/docs",
@@ -16,12 +16,31 @@
     "url": "git+https://github.com/Rimelight-Entertainment/rimelight.git"
   },
   "files": [
+    "dist",
     "src"
   ],
   "type": "module",
   "exports": {
-    ".": "./src/index.ts",
-    "./schema": "./src/schema/index.ts",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./schema": {
+      "types": "./dist/schema/index.d.mts",
+      "import": "./dist/schema/index.mjs"
+    },
+    "./schema/sqlite": {
+      "types": "./dist/schema/sqlite.d.mts",
+      "import": "./dist/schema/sqlite.mjs"
+    },
+    "./integration": {
+      "types": "./dist/integration.d.mts",
+      "import": "./dist/integration.mjs"
+    },
+    "./storage": {
+      "types": "./dist/storage/index.d.mts",
+      "import": "./dist/storage/index.mjs"
+    },
     "./core/*": "./src/core/*",
     "./astro/*": "./src/astro/*",
     "./client/styles/*": "./src/client/styles/*",
@@ -33,37 +52,36 @@
     "./client/*": "./src/client/*.ts",
     "./auth/*": "./src/auth/*",
     "./cache/*": "./src/cache/*",
-    "./search/*": "./src/search/*"
+    "./search/*": "./src/search/*",
+    "./admin/*": "./src/admin/*"
   },
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "check": "pnpm audit --audit-level=moderate && vp check --fix && astro check"
-  },
   "dependencies": {
-    "@rimelight/i18n": "0.0.5",
-    "@rimelight/ui": "0.0.43",
+    "@rimelight/auth": "0.0.3",
+    "@rimelight/i18n": "0.0.7",
+    "@rimelight/ui": "0.0.46",
     "drizzle-orm": "0.45.2",
     "solid-js": "1.9.15",
     "sortablejs": "1.15.7"
   },
   "devDependencies": {
     "@astrojs/check": "0.9.10",
-    "@rimelight/config": "0.0.1",
+    "@rimelight/config": "0.0.4",
     "@types/sortablejs": "1.15.9",
-    "astro": "7.2.2",
-    "better-auth": "1.6.30",
+    "astro": "7.3.1",
     "typescript": "6.0.3",
-    "unocss": "66.7.5",
-    "vitest": "4.1.10"
+    "unocss": "66.10.0"
   },
   "peerDependencies": {
-    "astro": ">=7.0.0",
-    "better-auth": ">=1.0.0"
+    "astro": ">=7.0.0"
   },
   "engines": {
     "node": ">=26.7.0"
   },
-  "packageManager": "pnpm@11.22.0"
-}
+  "scripts": {
+    "build": "vp pack",
+    "check": "vp check --fix && astro check"
+  }
+}

package/src/admin/api/media-file.ts

@@ -0,0 +1,39 @@
+import type { APIRoute } from "astro"
+import { getR2Bucket } from "../../storage/index"
+// @ts-ignore
+import { storageConfig } from "virtual:rimelight-cms/storage"
+
+export const prerender = false
+
+export const GET: APIRoute = async ({ params, locals }) => {
+  try {
+    const bindingName = storageConfig?.binding ?? "BLOB"
+    const bucket = await getR2Bucket(locals, bindingName)
+
+    if (!bucket) {
+      return new Response("Storage binding not found.", { status: 500 })
+    }
+
+    const key = params.key as string
+    if (!key) {
+      return new Response("Missing file key.", { status: 400 })
+    }
+
+    const object = await bucket.get(key)
+    if (!object) {
+      return new Response("File not found in R2 storage.", { status: 404 })
+    }
+
+    const headers = new Headers()
+    object.writeHttpMetadata(headers)
+    headers.set("etag", object.httpEtag)
+    headers.set("Cache-Control", "public, max-age=31536000, immutable")
+
+    return new Response(object.body, {
+      status: 200,
+      headers
+    })
+  } catch (error: any) {
+    return new Response(error.message || "Failed to retrieve file", { status: 500 })
+  }
+}