@kidecms/core 0.1.0

package/dist/assets.js

@@ -0,0 +1,163 @@
+import { desc, eq, isNull, sql } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { getDb, getStorage } from "./runtime";
+import { getSchema } from "./schema";
+export const assets = {
+    async upload(file, options) {
+        const db = await getDb();
+        const schema = getSchema();
+        const storage = getStorage();
+        const ext = file.name.includes(".") ? file.name.slice(file.name.lastIndexOf(".")) : "";
+        const safeName = `${nanoid(12)}${ext}`;
+        const storagePath = `/uploads/${safeName}`;
+        await storage.putFile(storagePath, new Uint8Array(await file.arrayBuffer()));
+        const id = nanoid();
+        const createdAt = new Date().toISOString();
+        const folder = options?.folder || null;
+        await db.insert(schema.cmsAssets).values({
+            _id: id,
+            filename: file.name,
+            mimeType: file.type || "application/octet-stream",
+            size: file.size,
+            width: null,
+            height: null,
+            alt: options?.alt ?? null,
+            folder,
+            storagePath,
+            _createdAt: createdAt,
+        });
+        return {
+            _id: id,
+            filename: file.name,
+            mimeType: file.type || "application/octet-stream",
+            size: file.size,
+            width: null,
+            height: null,
+            focalX: null,
+            focalY: null,
+            alt: options?.alt ?? null,
+            folder,
+            storagePath,
+            url: storagePath,
+            _createdAt: createdAt,
+        };
+    },
+    async find(options = {}) {
+        const db = await getDb();
+        const schema = getSchema();
+        const condition = options.folder !== undefined
+            ? options.folder === null
+                ? isNull(schema.cmsAssets.folder)
+                : eq(schema.cmsAssets.folder, options.folder)
+            : undefined;
+        let query = db.select().from(schema.cmsAssets).where(condition).orderBy(desc(schema.cmsAssets._createdAt));
+        if (options.limit)
+            query = query.limit(options.limit);
+        if (options.offset)
+            query = query.offset(options.offset);
+        const rows = await query;
+        return rows.map((row) => ({ ...row, url: row.storagePath }));
+    },
+    async findById(id) {
+        const db = await getDb();
+        const schema = getSchema();
+        const rows = await db.select().from(schema.cmsAssets).where(eq(schema.cmsAssets._id, id)).limit(1);
+        if (rows.length === 0)
+            return null;
+        const row = rows[0];
+        return { ...row, url: row.storagePath };
+    },
+    async findByUrl(url) {
+        const db = await getDb();
+        const schema = getSchema();
+        const rows = await db.select().from(schema.cmsAssets).where(eq(schema.cmsAssets.storagePath, url)).limit(1);
+        if (rows.length === 0)
+            return null;
+        const row = rows[0];
+        return { ...row, url: row.storagePath };
+    },
+    async delete(id) {
+        const db = await getDb();
+        const schema = getSchema();
+        const storage = getStorage();
+        const rows = await db.select().from(schema.cmsAssets).where(eq(schema.cmsAssets._id, id)).limit(1);
+        if (rows.length === 0)
+            return;
+        const asset = rows[0];
+        await storage.deleteFile(asset.storagePath);
+        await db.delete(schema.cmsAssets).where(eq(schema.cmsAssets._id, id));
+    },
+    async update(id, data) {
+        const db = await getDb();
+        const schema = getSchema();
+        const rows = await db.select().from(schema.cmsAssets).where(eq(schema.cmsAssets._id, id)).limit(1);
+        if (rows.length === 0)
+            return null;
+        const updateValues = {};
+        if (data.alt !== undefined)
+            updateValues.alt = data.alt;
+        if (data.filename !== undefined)
+            updateValues.filename = data.filename;
+        if (data.folder !== undefined)
+            updateValues.folder = data.folder;
+        if (data.focalX !== undefined)
+            updateValues.focalX = data.focalX;
+        if (data.focalY !== undefined)
+            updateValues.focalY = data.focalY;
+        if (Object.keys(updateValues).length > 0) {
+            await db.update(schema.cmsAssets).set(updateValues).where(eq(schema.cmsAssets._id, id));
+        }
+        return this.findById(id);
+    },
+    async count() {
+        const db = await getDb();
+        const schema = getSchema();
+        const rows = await db.select({ count: sql `count(*)` }).from(schema.cmsAssets);
+        return Number(rows[0]?.count ?? 0);
+    },
+};
+export const folders = {
+    async create(name, parent) {
+        const db = await getDb();
+        const schema = getSchema();
+        const id = nanoid();
+        const createdAt = new Date().toISOString();
+        await db.insert(schema.cmsAssetFolders).values({
+            _id: id,
+            name,
+            parent: parent ?? null,
+            _createdAt: createdAt,
+        });
+        return { _id: id, name, parent: parent ?? null, _createdAt: createdAt };
+    },
+    async findByParent(parent) {
+        const db = await getDb();
+        const schema = getSchema();
+        const condition = parent === null ? isNull(schema.cmsAssetFolders.parent) : eq(schema.cmsAssetFolders.parent, parent);
+        const rows = await db.select().from(schema.cmsAssetFolders).where(condition).orderBy(schema.cmsAssetFolders.name);
+        return rows;
+    },
+    async findById(id) {
+        const db = await getDb();
+        const schema = getSchema();
+        const rows = await db.select().from(schema.cmsAssetFolders).where(eq(schema.cmsAssetFolders._id, id)).limit(1);
+        return rows.length > 0 ? rows[0] : null;
+    },
+    async findAll() {
+        const db = await getDb();
+        const schema = getSchema();
+        const rows = await db.select().from(schema.cmsAssetFolders).orderBy(schema.cmsAssetFolders.name);
+        return rows;
+    },
+    async rename(id, name) {
+        const db = await getDb();
+        const schema = getSchema();
+        await db.update(schema.cmsAssetFolders).set({ name }).where(eq(schema.cmsAssetFolders._id, id));
+        return this.findById(id);
+    },
+    async delete(id) {
+        const db = await getDb();
+        const schema = getSchema();
+        await db.delete(schema.cmsAssetFolders).where(eq(schema.cmsAssetFolders._id, id));
+    },
+};

package/dist/auth.js

@@ -0,0 +1,132 @@
+import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import { getDb } from "./runtime";
+import { getSchema } from "./schema";
+const ITERATIONS = 100_000;
+const HASH_LENGTH = 32;
+const SALT_LENGTH = 16;
+const encode = (buffer) => btoa(String.fromCharCode(...new Uint8Array(buffer)));
+const decode = (base64) => Uint8Array.from(atob(base64), (char) => char.charCodeAt(0));
+const deriveKey = async (plain, salt) => {
+    const keyMaterial = await crypto.subtle.importKey("raw", new TextEncoder().encode(plain), "PBKDF2", false, [
+        "deriveBits",
+    ]);
+    return crypto.subtle.deriveBits({ name: "PBKDF2", salt: salt.buffer, iterations: ITERATIONS, hash: "SHA-256" }, keyMaterial, HASH_LENGTH * 8);
+};
+export const hashPassword = async (plain) => {
+    const salt = crypto.getRandomValues(new Uint8Array(SALT_LENGTH));
+    const derived = await deriveKey(plain, salt);
+    return `pbkdf2:${ITERATIONS}:${encode(salt.buffer)}:${encode(derived)}`;
+};
+export const verifyPassword = async (hash, plain) => {
+    const [, iterStr, saltB64, hashB64] = hash.split(":");
+    if (!iterStr || !saltB64 || !hashB64)
+        return false;
+    const salt = decode(saltB64);
+    const expected = decode(hashB64);
+    const keyMaterial = await crypto.subtle.importKey("raw", new TextEncoder().encode(plain), "PBKDF2", false, [
+        "deriveBits",
+    ]);
+    const derived = new Uint8Array(await crypto.subtle.deriveBits({ name: "PBKDF2", salt, iterations: Number(iterStr), hash: "SHA-256" }, keyMaterial, expected.length * 8));
+    if (derived.length !== expected.length)
+        return false;
+    let diff = 0;
+    for (let i = 0; i < derived.length; i++)
+        diff |= derived[i] ^ expected[i];
+    return diff === 0;
+};
+export const createSession = async (userId) => {
+    const db = await getDb();
+    const schema = getSchema();
+    const token = nanoid(32);
+    const expiresAt = new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+    await db.insert(schema.cmsSessions).values({
+        _id: token,
+        userId,
+        expiresAt,
+    });
+    return { token, expiresAt };
+};
+export const validateSession = async (token) => {
+    const db = await getDb();
+    const schema = getSchema();
+    const rows = await db.select().from(schema.cmsSessions).where(eq(schema.cmsSessions._id, token)).limit(1);
+    if (rows.length === 0)
+        return null;
+    const session = rows[0];
+    if (new Date(session.expiresAt) < new Date()) {
+        await db.delete(schema.cmsSessions).where(eq(schema.cmsSessions._id, token));
+        return null;
+    }
+    return { userId: session.userId, expiresAt: session.expiresAt };
+};
+export const destroySession = async (token) => {
+    const db = await getDb();
+    const schema = getSchema();
+    await db.delete(schema.cmsSessions).where(eq(schema.cmsSessions._id, token));
+};
+export const getSessionUser = async (request) => {
+    const cookieHeader = request.headers.get("cookie") ?? "";
+    const match = cookieHeader.match(/cms_session=([^;]+)/);
+    if (!match)
+        return null;
+    const session = await validateSession(match[1]);
+    if (!session)
+        return null;
+    const db = await getDb();
+    const schema = getSchema();
+    const tables = schema.cmsTables;
+    if (!tables.users)
+        return null;
+    const userRows = await db.select().from(tables.users.main).where(eq(tables.users.main._id, session.userId)).limit(1);
+    if (userRows.length === 0)
+        return null;
+    const user = userRows[0];
+    return {
+        id: String(user._id),
+        email: String(user.email),
+        name: String(user.name),
+        role: String(user.role),
+    };
+};
+const INVITE_EXPIRY_DAYS = 7;
+export const createInvite = async (userId) => {
+    const db = await getDb();
+    const schema = getSchema();
+    const token = nanoid(32);
+    const expiresAt = new Date(Date.now() + INVITE_EXPIRY_DAYS * 24 * 60 * 60 * 1000).toISOString();
+    await db.insert(schema.cmsInvites).values({
+        _id: nanoid(),
+        userId,
+        token,
+        expiresAt,
+    });
+    return { token, expiresAt };
+};
+export const validateInvite = async (token) => {
+    const db = await getDb();
+    const schema = getSchema();
+    const rows = await db.select().from(schema.cmsInvites).where(eq(schema.cmsInvites.token, token)).limit(1);
+    if (rows.length === 0)
+        return null;
+    const invite = rows[0];
+    if (invite.usedAt)
+        return null;
+    if (new Date(invite.expiresAt) < new Date())
+        return null;
+    return { userId: invite.userId, expiresAt: invite.expiresAt };
+};
+export const consumeInvite = async (token) => {
+    const db = await getDb();
+    const schema = getSchema();
+    await db
+        .update(schema.cmsInvites)
+        .set({ usedAt: new Date().toISOString() })
+        .where(eq(schema.cmsInvites.token, token));
+};
+export const SESSION_COOKIE_NAME = "cms_session";
+export const setSessionCookie = (token, expiresAt) => {
+    const secure = process.env.NODE_ENV === "production" ? "; Secure" : "";
+    return `${SESSION_COOKIE_NAME}=${token}; Path=/; HttpOnly; SameSite=Strict${secure}; Expires=${new Date(expiresAt).toUTCString()}`;
+};
+export const clearSessionCookie = () => `${SESSION_COOKIE_NAME}=; Path=/; HttpOnly; SameSite=Strict; Max-Age=0`;

package/dist/blocks.js

@@ -0,0 +1,110 @@
+import { cmsImage, cmsSrcset } from "./image";
+import { renderRichText } from "./richtext";
+function esc(value) {
+    return String(value ?? "")
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function parseJson(value) {
+    if (typeof value === "string") {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    return value;
+}
+function isRichText(value) {
+    const parsed = parseJson(value);
+    return parsed && typeof parsed === "object" && parsed.type === "root";
+}
+function isImageUrl(value) {
+    const stringValue = String(value ?? "");
+    return stringValue.startsWith("/uploads/") || stringValue.startsWith("http://") || stringValue.startsWith("https://");
+}
+function isImageArray(value) {
+    const parsed = parseJson(value);
+    return Array.isArray(parsed) && parsed.length > 0 && parsed.every((entry) => isImageUrl(entry));
+}
+function isRepeaterArray(value) {
+    const parsed = parseJson(value);
+    return Array.isArray(parsed) && parsed.length > 0 && typeof parsed[0] === "object" && parsed[0] !== null;
+}
+function renderImage(src) {
+    if (src.startsWith("/uploads/")) {
+        return `<img src="${esc(cmsImage(src, 1024))}" srcset="${esc(cmsSrcset(src))}" sizes="(max-width: 768px) 100vw, 768px" alt="" loading="lazy" class="h-auto w-full rounded-lg object-cover" />`;
+    }
+    return `<img src="${esc(src)}" alt="" loading="lazy" class="w-full rounded-lg object-cover" />`;
+}
+function renderFieldValue(key, value) {
+    if (value === null || value === undefined || value === "")
+        return "";
+    const parsed = parseJson(value);
+    if (isRichText(value)) {
+        return `<div class="prose">${renderRichText(parsed)}</div>`;
+    }
+    if (isImageArray(value)) {
+        const images = Array.isArray(parsed) ? parsed : [];
+        return `<div class="grid gap-4">${images.map((src) => renderImage(String(src))).join("")}</div>`;
+    }
+    if (isImageUrl(value)) {
+        return renderImage(String(value));
+    }
+    if (isRepeaterArray(value)) {
+        const items = Array.isArray(parsed) ? parsed : [];
+        let html = `<div class="grid gap-3">`;
+        for (const item of items) {
+            html += `<div class="rounded-lg border border-gray-200 bg-gray-50 px-5 py-4">`;
+            for (const [itemKey, itemValue] of Object.entries(item)) {
+                if (itemKey === "_key" || itemKey === "id" || !itemValue)
+                    continue;
+                const className = itemKey.includes("description") || itemKey.includes("answer") || itemKey.includes("body")
+                    ? "m-0 text-gray-500"
+                    : "mb-1 font-semibold";
+                html += `<p class="${className}">${esc(itemValue)}</p>`;
+            }
+            html += `</div>`;
+        }
+        html += `</div>`;
+        return html;
+    }
+    if (key === "heading" || key === "title") {
+        return `<h2 class="mb-3 text-xl font-semibold">${esc(value)}</h2>`;
+    }
+    if (key === "eyebrow" || key === "label") {
+        return `<p class="mb-1 text-xs font-semibold uppercase tracking-wide text-teal-700">${esc(value)}</p>`;
+    }
+    if (key === "ctaLabel" || key === "ctaHref") {
+        return "";
+    }
+    return `<p class="text-gray-500">${esc(value)}</p>`;
+}
+export function renderBlock(block) {
+    const { type: _type, _key, ...fields } = block;
+    let html = `<section>`;
+    if (fields.eyebrow) {
+        html += renderFieldValue("eyebrow", fields.eyebrow);
+    }
+    for (const key of ["heading", "title"]) {
+        if (fields[key]) {
+            html += renderFieldValue(key, fields[key]);
+        }
+    }
+    for (const [key, value] of Object.entries(fields)) {
+        if (["eyebrow", "heading", "title", "ctaLabel", "ctaHref"].includes(key))
+            continue;
+        html += renderFieldValue(key, value);
+    }
+    if (fields.ctaLabel && fields.ctaHref) {
+        html += `<a href="${esc(fields.ctaHref)}" class="mt-4 inline-block rounded-md bg-teal-700 px-4 py-2 text-sm text-white no-underline">${esc(fields.ctaLabel)}</a>`;
+    }
+    html += `</section>`;
+    return html;
+}
+export function renderBlocks(blocks) {
+    return blocks.map(renderBlock).join("");
+}

package/dist/content.js

@@ -0,0 +1,29 @@
+export function parseBlocks(value) {
+    if (!value)
+        return [];
+    try {
+        const parsed = typeof value === "string" ? JSON.parse(value) : value;
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function parseList(value) {
+    if (Array.isArray(value))
+        return value;
+    if (typeof value === "string") {
+        try {
+            const parsed = JSON.parse(value);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    return [];
+}
+export function cacheTags(collection, docId) {
+    const singular = collection.endsWith("s") ? collection.slice(0, -1) : collection;
+    return [collection, `${singular}:${docId}`];
+}

package/dist/create-admin.js

@@ -0,0 +1,23 @@
+import { nanoid } from "nanoid";
+import { hashPassword } from "./auth";
+import { getDb } from "./runtime";
+import { getSchema } from "./schema";
+export const createAdminUser = async (input) => {
+    const db = await getDb();
+    const schema = getSchema();
+    const tables = schema.cmsTables;
+    if (!tables.users) {
+        throw new Error("No users collection found.");
+    }
+    const now = new Date().toISOString();
+    const hashedPassword = await hashPassword(input.password);
+    await db.insert(tables.users.main).values({
+        _id: nanoid(),
+        name: input.name,
+        email: input.email,
+        password: hashedPassword,
+        role: "admin",
+        _createdAt: now,
+        _updatedAt: now,
+    });
+};

package/dist/define.js

@@ -0,0 +1,36 @@
+export const hasRole = (...roles) => ({ user }) => !!user?.role && roles.includes(user.role);
+const createField = (type, options) => ({ type, ...(options ?? {}) });
+export const fields = {
+    text: (options) => createField("text", options),
+    slug: (options) => createField("slug", options),
+    email: (options) => createField("email", options),
+    number: (options) => createField("number", options),
+    boolean: (options) => createField("boolean", options),
+    date: (options) => createField("date", options),
+    select: (options) => createField("select", options),
+    richText: (options) => createField("richText", options),
+    image: (options) => createField("image", options),
+    relation: (options) => createField("relation", options),
+    array: (options) => createField("array", options),
+    json: (options) => createField("json", options),
+    blocks: (options) => createField("blocks", options),
+};
+export const defineCollection = (collection) => collection;
+export const defineConfig = (config) => config;
+export const getCollectionMap = (config) => Object.fromEntries(config.collections.map((collection) => [collection.slug, collection]));
+export const getDefaultLocale = (config) => config.locales?.default ?? null;
+export const getTranslatableFieldNames = (collection) => Object.entries(collection.fields)
+    .filter(([, field]) => field.translatable)
+    .map(([name]) => name);
+export const isStructuralField = (field) => ["number", "boolean", "relation", "image", "date"].includes(field.type);
+export const getCollectionLabel = (collection) => collection.labels.plural;
+export const getLabelField = (collection) => {
+    if (collection.labelField && collection.labelField in collection.fields)
+        return collection.labelField;
+    if ("title" in collection.fields)
+        return "title";
+    if ("name" in collection.fields)
+        return "name";
+    const firstTextField = Object.entries(collection.fields).find(([, field]) => field.type === "text");
+    return firstTextField ? firstTextField[0] : Object.keys(collection.fields)[0];
+};