@kidecms/core 0.1.0

package/dist/generator.js

@@ -0,0 +1,370 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getTranslatableFieldNames } from "./define";
+const pascalCase = (value) => value
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+const snakeCase = (value) => value
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/[^a-zA-Z0-9]+/g, "_")
+    .toLowerCase();
+const isJsonField = (field) => field.type === "richText" ||
+    field.type === "array" ||
+    field.type === "json" ||
+    field.type === "blocks" ||
+    (field.type === "relation" && field.hasMany);
+const generateColumnDef = (fieldName, field) => {
+    const colName = snakeCase(fieldName);
+    let col;
+    if (field.type === "number") {
+        col = `integer("${colName}")`;
+    }
+    else if (field.type === "boolean") {
+        col = `integer("${colName}", { mode: "boolean" })`;
+    }
+    else {
+        col = `text("${colName}")`;
+    }
+    if (field.required && !field.condition)
+        col += ".notNull()";
+    if (field.unique)
+        col += ".unique()";
+    if (field.defaultValue !== undefined && !isJsonField(field)) {
+        if (field.type === "number" || field.type === "boolean") {
+            col += `.default(${field.defaultValue})`;
+        }
+        else {
+            col += `.default(${JSON.stringify(field.defaultValue)})`;
+        }
+    }
+    return `  ${fieldName}: ${col},`;
+};
+const generateMainTable = (collection) => {
+    const tableName = `cms_${snakeCase(collection.slug)}`;
+    const varName = `cms${pascalCase(collection.slug)}`;
+    const columns = [`  _id: text("_id").primaryKey(),`];
+    for (const [fieldName, field] of Object.entries(collection.fields)) {
+        columns.push(generateColumnDef(fieldName, field));
+    }
+    if (collection.drafts) {
+        columns.push(`  _status: text("_status").notNull().default("draft"),`);
+        columns.push(`  _publishedAt: text("_published_at"),`);
+        columns.push(`  _publishAt: text("_publish_at"),`);
+        columns.push(`  _unpublishAt: text("_unpublish_at"),`);
+        columns.push(`  _published: text("_published"),`);
+    }
+    if (collection.timestamps !== false) {
+        columns.push(`  _createdAt: text("_created_at").notNull(),`);
+        columns.push(`  _updatedAt: text("_updated_at").notNull(),`);
+    }
+    return `export const ${varName} = sqliteTable("${tableName}", {\n${columns.join("\n")}\n});`;
+};
+const generateTranslationsTable = (config, collection) => {
+    if (!config.locales)
+        return null;
+    const translatableFields = getTranslatableFieldNames(collection);
+    if (translatableFields.length === 0)
+        return null;
+    const tableName = `cms_${snakeCase(collection.slug)}_translations`;
+    const varName = `cms${pascalCase(collection.slug)}Translations`;
+    const mainVar = `cms${pascalCase(collection.slug)}`;
+    const columns = [
+        `  _id: text("_id").primaryKey(),`,
+        `  _entityId: text("_entity_id").notNull().references(() => ${mainVar}._id, { onDelete: "cascade" }),`,
+        `  _languageCode: text("_language_code").notNull(),`,
+    ];
+    for (const fieldName of translatableFields) {
+        columns.push(generateColumnDef(fieldName, collection.fields[fieldName]));
+    }
+    return `export const ${varName} = sqliteTable("${tableName}", {\n${columns.join("\n")}\n}, (table) => ({\n  uniqueLocale: unique().on(table._entityId, table._languageCode),\n}));`;
+};
+const generateVersionsTable = (collection) => {
+    if (!collection.versions)
+        return null;
+    const tableName = `cms_${snakeCase(collection.slug)}_versions`;
+    const varName = `cms${pascalCase(collection.slug)}Versions`;
+    const mainVar = `cms${pascalCase(collection.slug)}`;
+    return `export const ${varName} = sqliteTable("${tableName}", {
+  _id: text("_id").primaryKey(),
+  _docId: text("_doc_id").notNull().references(() => ${mainVar}._id, { onDelete: "cascade" }),
+  _version: integer("_version").notNull(),
+  _snapshot: text("_snapshot").notNull(),
+  _createdAt: text("_created_at").notNull(),
+});`;
+};
+const generateSchemaFile = (config) => {
+    const parts = [
+        `// auto-generated — do not edit`,
+        `import { sqliteTable, text, integer, real, unique } from "drizzle-orm/sqlite-core";`,
+        ``,
+    ];
+    for (const collection of config.collections) {
+        parts.push(generateMainTable(collection));
+        const translationsTable = generateTranslationsTable(config, collection);
+        if (translationsTable)
+            parts.push("", translationsTable);
+        const versionsTable = generateVersionsTable(collection);
+        if (versionsTable)
+            parts.push("", versionsTable);
+        parts.push("");
+    }
+    parts.push(`export const cmsAssets = sqliteTable("cms_assets", {
+  _id: text("_id").primaryKey(),
+  filename: text("filename").notNull(),
+  mimeType: text("mime_type").notNull(),
+  size: integer("size").notNull(),
+  width: integer("width"),
+  height: integer("height"),
+  focalX: real("focal_x"),
+  focalY: real("focal_y"),
+  alt: text("alt"),
+  folder: text("folder"),
+  storagePath: text("storage_path").notNull(),
+  _createdAt: text("_created_at").notNull(),
+});`);
+    parts.push("");
+    parts.push(`export const cmsAssetFolders = sqliteTable("cms_asset_folders", {
+  _id: text("_id").primaryKey(),
+  name: text("name").notNull(),
+  parent: text("parent"),
+  _createdAt: text("_created_at").notNull(),
+});`);
+    parts.push("");
+    parts.push(`export const cmsSessions = sqliteTable("cms_sessions", {
+  _id: text("_id").primaryKey(),
+  userId: text("user_id").notNull(),
+  expiresAt: text("expires_at").notNull(),
+});`);
+    parts.push("");
+    parts.push(`export const cmsLocks = sqliteTable("cms_locks", {
+  _id: text("_id").primaryKey(),
+  collection: text("collection").notNull(),
+  documentId: text("document_id").notNull(),
+  userId: text("user_id").notNull(),
+  userEmail: text("user_email").notNull(),
+  lockedAt: text("locked_at").notNull(),
+});`);
+    parts.push("");
+    parts.push(`export const cmsInvites = sqliteTable("cms_invites", {
+  _id: text("_id").primaryKey(),
+  userId: text("user_id").notNull(),
+  token: text("token").notNull().unique(),
+  expiresAt: text("expires_at").notNull(),
+  usedAt: text("used_at"),
+});`);
+    parts.push("");
+    const tableExports = [];
+    for (const collection of config.collections) {
+        const varName = `cms${pascalCase(collection.slug)}`;
+        const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(collection.slug) ? collection.slug : `"${collection.slug}"`;
+        tableExports.push(`  ${safeKey}: { main: ${varName}`);
+        const translatableFields = getTranslatableFieldNames(collection);
+        if (translatableFields.length > 0 && config.locales) {
+            tableExports[tableExports.length - 1] += `, translations: ${varName}Translations`;
+        }
+        if (collection.versions) {
+            tableExports[tableExports.length - 1] += `, versions: ${varName}Versions`;
+        }
+        tableExports[tableExports.length - 1] += ` },`;
+    }
+    parts.push(`export const cmsTables = {\n${tableExports.join("\n")}\n};`);
+    return parts.join("\n");
+};
+const zodTypeForField = (field) => {
+    if (["text", "slug", "email", "image", "date"].includes(field.type)) {
+        let zodType = "z.string()";
+        if (field.type === "email")
+            zodType = "z.string().email()";
+        if (field.type === "text" && field.maxLength)
+            zodType = `z.string().max(${field.maxLength})`;
+        return zodType;
+    }
+    if (field.type === "number")
+        return "z.number()";
+    if (field.type === "boolean")
+        return "z.boolean()";
+    if (field.type === "select")
+        return `z.enum([${field.options.map((option) => JSON.stringify(option)).join(", ")}])`;
+    if (field.type === "relation")
+        return field.hasMany ? "z.array(z.string())" : "z.string()";
+    if (field.type === "array")
+        return `z.array(${zodTypeForField(field.of)})`;
+    if (field.type === "richText")
+        return "z.object({ type: z.literal('root'), children: z.array(z.any()) })";
+    if (field.type === "json")
+        return "z.record(z.unknown())";
+    if (field.type === "blocks") {
+        const variants = Object.entries(field.types).map(([blockType, fields]) => {
+            const members = Object.entries(fields)
+                .map(([fieldName, nestedField]) => `${fieldName}: ${zodTypeForField(nestedField)}${nestedField.required ? "" : ".optional()"}`)
+                .join(", ");
+            return `z.object({ type: z.literal(${JSON.stringify(blockType)}), ${members} })`;
+        });
+        if (variants.length === 0)
+            return "z.array(z.record(z.unknown()))";
+        if (variants.length === 1)
+            return `z.array(${variants[0]})`;
+        return `z.array(z.discriminatedUnion("type", [\n    ${variants.join(",\n    ")},\n  ]))`;
+    }
+    return "z.unknown()";
+};
+const generateValidatorsFile = (config) => {
+    const parts = [`// auto-generated — do not edit`, `import { z } from "zod";`, ``];
+    for (const collection of config.collections) {
+        const name = pascalCase(collection.slug);
+        const fieldEntries = Object.entries(collection.fields).map(([fieldName, field]) => {
+            const zodType = zodTypeForField(field);
+            const isOptional = !field.required || !!field.condition;
+            return `  ${fieldName}: ${zodType}${isOptional ? ".optional()" : ""},`;
+        });
+        parts.push(`export const ${name}CreateSchema = z.object({\n${fieldEntries.join("\n")}\n});`);
+        parts.push("");
+        const partialEntries = Object.entries(collection.fields).map(([fieldName, field]) => {
+            const zodType = zodTypeForField(field);
+            return `  ${fieldName}: ${zodType}.optional(),`;
+        });
+        parts.push(`export const ${name}UpdateSchema = z.object({\n${partialEntries.join("\n")}\n});`);
+        parts.push("");
+    }
+    const mapEntries = config.collections.map((collection) => {
+        const name = pascalCase(collection.slug);
+        return `  ${collection.slug}: { create: ${name}CreateSchema, update: ${name}UpdateSchema },`;
+    });
+    parts.push(`export const validators = {\n${mapEntries.join("\n")}\n};`);
+    return parts.join("\n");
+};
+const typeForField = (field) => {
+    if (["text", "slug", "email", "image", "date"].includes(field.type))
+        return "string";
+    if (field.type === "number")
+        return "number";
+    if (field.type === "boolean")
+        return "boolean";
+    if (field.type === "select")
+        return field.options.map((option) => JSON.stringify(option)).join(" | ");
+    if (field.type === "relation")
+        return field.hasMany ? "string[]" : "string";
+    if (field.type === "array")
+        return `${typeForField(field.of)}[]`;
+    if (field.type === "richText")
+        return "RichTextDocument";
+    if (field.type === "json")
+        return "Record<string, unknown>";
+    if (field.type === "blocks") {
+        const variants = Object.entries(field.types).map(([blockType, fields]) => {
+            const members = Object.entries(fields)
+                .map(([fieldName, nestedField]) => `${fieldName}${nestedField.required ? "" : "?"}: ${typeForField(nestedField)};`)
+                .join(" ");
+            return `{ type: ${JSON.stringify(blockType)}; ${members} }`;
+        });
+        return `Array<${variants.join(" | ")}>`;
+    }
+    return "unknown";
+};
+const generateTypesFile = (config, coreImportPath) => {
+    const parts = [
+        `// auto-generated — do not edit`,
+        `import type { RichTextDocument } from "${coreImportPath}";`,
+        ``,
+        `export type CMSCollectionSlug = ${config.collections.map((collection) => JSON.stringify(collection.slug)).join(" | ")};`,
+        ``,
+    ];
+    for (const collection of config.collections) {
+        const docName = `${pascalCase(collection.slug)}Document`;
+        const inputName = `${pascalCase(collection.slug)}Input`;
+        const translationName = `${pascalCase(collection.slug)}TranslationInput`;
+        const translatableFields = getTranslatableFieldNames(collection);
+        const fieldEntries = Object.entries(collection.fields)
+            .map(([fieldName, field]) => {
+            const isOptional = !field.required || !!field.condition;
+            return `  ${fieldName}${isOptional ? "?" : ""}: ${typeForField(field)};`;
+        })
+            .join("\n");
+        const translationEntries = translatableFields.length
+            ? translatableFields
+                .map((fieldName) => `  ${fieldName}?: ${typeForField(collection.fields[fieldName])};`)
+                .join("\n")
+            : "  [key: string]: never;";
+        parts.push(`export type ${inputName} = {\n${fieldEntries}\n};`);
+        parts.push("");
+        parts.push(`export type ${translationName} = {\n${translationEntries}\n};`);
+        parts.push("");
+        parts.push(`export type ${docName} = ${inputName} & {
+  _id: string;
+  _status: "draft" | "published" | "scheduled";
+  _publishedAt?: string | null;
+  _publishAt?: string | null;
+  _unpublishAt?: string | null;
+  _createdAt: string;
+  _updatedAt: string;
+  _locale?: string | null;
+  _availableLocales?: string[];
+};`);
+        parts.push("");
+    }
+    parts.push(`export type StoredVersion = {
+  version: number;
+  createdAt: string;
+  snapshot: Record<string, unknown>;
+};`);
+    return parts.join("\n");
+};
+const generateApiFile = (config, coreImportPath, runtimeImportPath, configImportPath) => {
+    const imports = config.collections
+        .map((collection) => {
+        const name = pascalCase(collection.slug);
+        return [`${name}Document`, `${name}Input`, `${name}TranslationInput`];
+    })
+        .flat();
+    const apiTypes = config.collections
+        .map((collection) => {
+        const baseName = pascalCase(collection.slug);
+        const ctx = `context?: { user?: { id: string; role?: string; email?: string } | null }`;
+        const apiKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(collection.slug) ? collection.slug : `"${collection.slug}"`;
+        return `  ${apiKey}: {
+    find(options?: import("${coreImportPath}").FindOptions, ${ctx}): Promise<${baseName}Document[]>;
+    findOne(filter: Record<string, unknown> & { locale?: string; status?: "draft" | "published" | "scheduled" | "any" }, ${ctx}): Promise<${baseName}Document | null>;
+    findById(id: string, options?: { locale?: string; status?: "draft" | "published" | "scheduled" | "any" }, ${ctx}): Promise<${baseName}Document | null>;
+    create(data: ${baseName}Input, ${ctx}): Promise<${baseName}Document>;
+    update(id: string, data: Partial<${baseName}Input>, ${ctx}): Promise<${baseName}Document>;
+    delete(id: string, ${ctx}): Promise<void>;
+    count(filter?: Omit<import("${coreImportPath}").FindOptions, "limit" | "offset" | "sort">, ${ctx}): Promise<number>;
+    versions(id: string): Promise<import("./types").StoredVersion[]>;
+    restore(id: string, versionNumber: number, ${ctx}): Promise<${baseName}Document>;
+    publish(id: string, ${ctx}): Promise<${baseName}Document>;
+    unpublish(id: string, ${ctx}): Promise<${baseName}Document>;
+    schedule(id: string, publishAt: string, unpublishAt?: string | null, ${ctx}): Promise<${baseName}Document>;
+    getTranslations(id: string): Promise<Record<string, ${baseName}TranslationInput>>;
+    upsertTranslation(id: string, locale: string, data: ${baseName}TranslationInput, ${ctx}): Promise<${baseName}Document>;
+  };`;
+    })
+        .join("\n");
+    return `// auto-generated — do not edit
+import config from "${configImportPath}";
+import { createCms } from "${runtimeImportPath}";
+import type {
+  ${imports.map((entry) => `${entry},`).join("\n  ")}
+} from "./types";
+
+export const cms = createCms(config) as {
+${apiTypes}
+  meta: ReturnType<typeof createCms>["meta"];
+  scheduled: ReturnType<typeof createCms>["scheduled"];
+};
+`;
+};
+export const generate = async (config, options) => {
+    const outputDir = options.outputDir;
+    const coreImportPath = options.coreImportPath ?? "@kidecms/core";
+    const runtimeImportPath = options.runtimeImportPath ?? "../runtime";
+    const configImportPath = options.configImportPath ?? "../cms.config";
+    await mkdir(outputDir, { recursive: true });
+    await Promise.all([
+        writeFile(path.join(outputDir, "schema.ts"), generateSchemaFile(config), "utf-8"),
+        writeFile(path.join(outputDir, "types.ts"), generateTypesFile(config, coreImportPath), "utf-8"),
+        writeFile(path.join(outputDir, "validators.ts"), generateValidatorsFile(config), "utf-8"),
+        writeFile(path.join(outputDir, "api.ts"), generateApiFile(config, coreImportPath, runtimeImportPath, configImportPath), "utf-8"),
+    ]);
+};

package/dist/image.js

@@ -0,0 +1,69 @@
+const ALLOWED_WIDTHS = [320, 480, 640, 768, 960, 1024, 1280, 1536, 1920];
+const ALLOWED_FORMATS = ["webp", "avif", "jpeg", "png"];
+function clampWidth(width) {
+    return ALLOWED_WIDTHS.reduce((prev, curr) => (Math.abs(curr - width) < Math.abs(prev - width) ? curr : prev));
+}
+function isCloudflare() {
+    return typeof navigator !== "undefined" && navigator.userAgent === "Cloudflare-Workers";
+}
+export function cmsImage(src, width, format = "webp") {
+    if (!src)
+        return "";
+    if (isCloudflare()) {
+        const parts = [];
+        if (width)
+            parts.push(`width=${clampWidth(width)}`);
+        parts.push(`format=${format}`);
+        parts.push("quality=80");
+        return `/cdn-cgi/image/${parts.join(",")}${src}`;
+    }
+    const params = new URLSearchParams();
+    if (width)
+        params.set("w", String(clampWidth(width)));
+    if (format !== "webp")
+        params.set("f", format);
+    const qs = params.toString();
+    return `/api/cms/img${src}${qs ? `?${qs}` : ""}`;
+}
+export function cmsSrcset(src, widths = [480, 768, 1024, 1280], format = "webp") {
+    if (!src)
+        return "";
+    return widths.map((width) => `${cmsImage(src, width, format)} ${width}w`).join(", ");
+}
+export async function transformImage(src, width, format, quality) {
+    const { existsSync, mkdirSync, readFileSync } = await import("node:fs");
+    const { writeFile } = await import("node:fs/promises");
+    const path = await import("node:path");
+    const sharpModule = "sharp";
+    const sharp = (await import(/* @vite-ignore */ sharpModule)).default;
+    const publicDir = path.join(process.cwd(), "public");
+    const cacheDir = path.join(process.cwd(), ".cms-cache", "img");
+    const filePath = path.join(publicDir, src);
+    if (!existsSync(filePath))
+        return null;
+    const resolvedFormat = ALLOWED_FORMATS.includes(format) ? format : "webp";
+    const resolvedWidth = width ? clampWidth(width) : undefined;
+    const resolvedQuality = quality ?? 80;
+    if (!existsSync(cacheDir))
+        mkdirSync(cacheDir, { recursive: true });
+    const safeName = src.replace(/[^a-zA-Z0-9.-]/g, "_");
+    const cacheKey = `${safeName}_${resolvedWidth ?? 0}.${resolvedFormat}`;
+    const cachePath = path.join(cacheDir, cacheKey);
+    if (existsSync(cachePath)) {
+        return {
+            buffer: readFileSync(cachePath),
+            contentType: `image/${resolvedFormat === "jpeg" ? "jpeg" : resolvedFormat}`,
+        };
+    }
+    let pipeline = sharp(readFileSync(filePath));
+    if (resolvedWidth) {
+        pipeline = pipeline.resize(resolvedWidth, undefined, { withoutEnlargement: true });
+    }
+    pipeline = pipeline.toFormat(resolvedFormat, { quality: resolvedQuality });
+    const buffer = await pipeline.toBuffer();
+    writeFile(cachePath, buffer).catch(() => { });
+    return {
+        buffer,
+        contentType: `image/${resolvedFormat === "jpeg" ? "jpeg" : resolvedFormat}`,
+    };
+}

package/dist/index.js

@@ -0,0 +1,16 @@
+export { configureCmsRuntime, resetCmsRuntime, getCmsRuntime, getDb, closeDb, getStorage, getEmail, readEnv, } from "./runtime";
+export { initSchema, getSchema, resetSchema } from "./schema";
+export { fields, defineCollection, defineConfig, getCollectionMap, getDefaultLocale, getTranslatableFieldNames, isStructuralField, getCollectionLabel, getLabelField, hasRole, } from "./define";
+export { createCms } from "./api";
+export { hashPassword, verifyPassword, createSession, validateSession, destroySession, getSessionUser, createInvite, validateInvite, consumeInvite, SESSION_COOKIE_NAME, setSessionCookie, clearSessionCookie, } from "./auth";
+export { assets, folders } from "./assets";
+export { parseBlocks, parseList, cacheTags } from "./content";
+export { renderRichText, createRichTextFromPlainText, richTextToPlainText } from "./richtext";
+export { cloneValue, slugify, escapeHtml, serializeFieldValue } from "./values";
+export { cmsImage, cmsSrcset, transformImage } from "./image";
+export { initDateFormat, formatDate, resolveAdminRoute, humanize, formatFieldValue, getListColumns, getFieldSets, } from "./admin";
+export { acquireLock, releaseLock } from "./locks";
+export { isAiEnabled, getAiModel, streamAltText, streamSeoDescription, streamTranslation } from "./ai";
+export { generate } from "./generator";
+export { seedDatabase } from "./seed";
+export { createAdminUser } from "./create-admin";