@mapled/cli 0.1.0

package/dist/types.js

@@ -0,0 +1,218 @@
+import { schemaHash } from "./schema.js";
+const IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const UNCOUNTABLE = new Set([
+    "news",
+    "series",
+    "species",
+    "media",
+    "data",
+    "status",
+    "analytics",
+    "press",
+    "staff",
+    "software",
+    "hardware",
+    "sheep",
+    "fish",
+]);
+/** A conservative singular: regular English plurals only. */
+export function singular(word) {
+    const lower = word.toLowerCase();
+    if (lower.length < 4 || UNCOUNTABLE.has(lower))
+        return word;
+    if (/[^aeiou]ies$/.test(lower))
+        return word.slice(0, -3) + "y";
+    if (/(sses|shes|ches|xes|zes)$/.test(lower))
+        return word.slice(0, -2);
+    if (/(ss|us|is)$/.test(lower))
+        return word;
+    if (lower.endsWith("s"))
+        return word.slice(0, -1);
+    return word;
+}
+export function pascal(words) {
+    const name = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+    if (!name)
+        return "Item";
+    return /^[0-9]/.test(name) ? `_${name}` : name;
+}
+function wordsOf(key) {
+    return key.split(/[^A-Za-z0-9]+/).filter(Boolean);
+}
+/** `blog-posts` → `BlogPost`; singles keep their name (`homepage` → `Homepage`). */
+export function typeName(key, kind) {
+    const words = wordsOf(key);
+    if (kind === "collection" && words.length > 0) {
+        words[words.length - 1] = singular(words[words.length - 1]);
+    }
+    return pascal(words);
+}
+function prop(key) {
+    return IDENT.test(key) ? key : JSON.stringify(key);
+}
+/** Doc-comment text is user content: it can never close the comment early. */
+function comment(text) {
+    return text.replace(/\*\//g, "* /").replace(/[\r\n]+/g, " ").trim();
+}
+function literalUnion(options) {
+    if (!options || options.length === 0)
+        return "string";
+    return options.map((o) => JSON.stringify(o)).join(" | ");
+}
+/** What the site receives for a field of this type. */
+function scalarType(type, options) {
+    switch (type) {
+        case "short_text":
+        case "long_text":
+        case "slug":
+        case "url":
+        case "email":
+            return { type: "string", note: type.replace("_", " ") };
+        case "rich_text":
+            return { type: "string", note: "rich text, Markdown" };
+        case "color":
+            return { type: "string", note: "color, #rrggbb" };
+        case "number":
+            return { type: "number", note: "number" };
+        case "boolean":
+            return { type: "boolean", note: "boolean" };
+        case "date":
+            return { type: "string", note: "date, YYYY-MM-DD" };
+        case "datetime":
+            return { type: "string", note: "date and time, ISO 8601" };
+        case "image":
+            return { type: "MapledAssetId", note: "image" };
+        case "file":
+            return { type: "MapledAssetId", note: "file" };
+        case "enum":
+            return { type: literalUnion(options), note: "choice" };
+        case "json":
+            return { type: "MapledJson", note: "JSON" };
+        case "location":
+            return { type: "MapledLocation", note: "location" };
+        default:
+            return { type: "unknown", note: type };
+    }
+}
+function fieldLine(key, displayName, required, rendered) {
+    const doc = `  /** ${comment(displayName)} — ${rendered.note} */`;
+    const line = required ? `  ${prop(key)}: ${rendered.type};` : `  ${prop(key)}?: ${rendered.type} | null;`;
+    return `${doc}\n${line}`;
+}
+function renderSubField(sub) {
+    return fieldLine(sub.key, sub.displayName, sub.required, scalarType(sub.type, sub.options));
+}
+function renderField(field, owner, names, extras) {
+    if (field.type === "relation" && field.relation) {
+        const target = names.get(field.relation.target) ?? field.relation.target;
+        const many = field.relation.cardinality === "many";
+        return fieldLine(field.key, field.displayName, field.required, {
+            type: many ? "MapledRecordId[]" : "MapledRecordId",
+            note: `relation to ${comment(target)}${many ? " (many)" : ""}`,
+        });
+    }
+    if (field.type === "group" && field.group) {
+        const itemName = `${owner}${pascal(wordsOf(field.key))}${field.group.repeatable ? "Item" : ""}`;
+        const kept = field.group.fields.filter((s) => s.sensitive !== true);
+        const hidden = field.group.fields.filter((s) => s.sensitive === true).map((s) => s.key);
+        const lines = kept.map(renderSubField);
+        if (hidden.length > 0)
+            lines.push(`  // Sensitive, never delivered: ${comment(hidden.join(", "))}`);
+        extras.push(`/** ${comment(field.displayName)} — ${field.group.repeatable ? "an item" : "the group"} of ${owner} */\n` +
+            `export interface ${itemName} {\n${lines.join("\n")}\n}`);
+        const note = field.group.repeatable
+            ? `group${field.group.maxItems ? `, up to ${field.group.maxItems} items` : ""}`
+            : "group";
+        return fieldLine(field.key, field.displayName, field.required, {
+            type: field.group.repeatable ? `${itemName}[]` : itemName,
+            note,
+        });
+    }
+    return fieldLine(field.key, field.displayName, field.required, scalarType(field.type, field.options));
+}
+/** Unique type names: the singular PascalCase of the key; the raw
+    PascalCase when two keys meet there; a numeric suffix as a last resort. */
+export function typeNames(collections) {
+    const preferred = collections.map((c) => typeName(c.key, c.kind));
+    const counts = new Map();
+    for (const name of preferred)
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    const taken = new Set();
+    const out = new Map();
+    collections.forEach((c, i) => {
+        let name = preferred[i];
+        if ((counts.get(name) ?? 0) > 1)
+            name = pascal(wordsOf(c.key));
+        let unique = name;
+        for (let n = 2; taken.has(unique); n++)
+            unique = `${name}${n}`;
+        taken.add(unique);
+        out.set(c.key, unique);
+    });
+    return out;
+}
+export function generateTypes(schema, opts = {}) {
+    const hash = schemaHash(schema);
+    const names = typeNames(schema.collections);
+    const blocks = [];
+    blocks.push([
+        "// Types of the published content this site reads through @mapled/next.",
+        "// Sensitive fields never reach the site and are left out.",
+        "",
+        '/** An asset id — pass it to assetUrl(id, { width }) from "@mapled/next". */',
+        "export type MapledAssetId = string;",
+        '/** The id of a record in another collection — attach it with { expand: ["field"] }. */',
+        "export type MapledRecordId = string;",
+        "/** A JSON value: an object or a list, up to 32 KB. */",
+        "export type MapledJson = Record<string, unknown> | unknown[];",
+        "export type MapledLocation = { lat: number; lng: number };",
+    ].join("\n"));
+    for (const c of schema.collections) {
+        const name = names.get(c.key);
+        const extras = [];
+        const kept = c.fields.filter((f) => !f.sensitive);
+        const hidden = c.fields.filter((f) => f.sensitive).map((f) => f.key);
+        const lines = kept.map((f) => renderField(f, name, names, extras));
+        if (hidden.length > 0)
+            lines.push(`  // Sensitive, never delivered: ${comment(hidden.join(", "))}`);
+        const traits = [
+            c.kind,
+            ...(c.mode && c.mode !== "editorial" ? [c.mode] : []),
+            ...(c.accessClass && c.accessClass !== "public" ? [`${c.accessClass} access`] : []),
+        ];
+        blocks.push(...extras);
+        blocks.push(`/** ${comment(c.displayName)} (${traits.join(", ")}) — key "${comment(c.key)}" */\n` +
+            `export interface ${name} {\n${lines.join("\n")}\n}`);
+    }
+    const collections = schema.collections.filter((c) => c.kind === "collection");
+    const singles = schema.collections.filter((c) => c.kind === "single");
+    const mapOf = (list) => list.length === 0 ? "{}" : `{\n${list.map((c) => `  ${prop(c.key)}: ${names.get(c.key)};`).join("\n")}\n}`;
+    blocks.push([
+        '/** Collections by key — getRecords<MapledCollections["articles"]>("articles"). */',
+        `export interface MapledCollections ${mapOf(collections)}`,
+        '/** Singles by key — getSingle<MapledSingles["homepage"]>("homepage"). */',
+        `export interface MapledSingles ${mapOf(singles)}`,
+        "export type MapledCollectionKey = keyof MapledCollections;",
+        "export type MapledSingleKey = keyof MapledSingles;",
+    ].join("\n"));
+    const body = blocks.join("\n\n") + "\n";
+    const header = [
+        "// Generated by `mapled types generate` — do not edit by hand; run it again after the schema changes.",
+        `// Project: ${comment(opts.projectName ?? "Mapled")} • schema ${hash}`,
+    ].join("\n");
+    return { text: `${header}\n\n${body}`, body, hash, collections: collections.length, singles: singles.length };
+}
+/** Splits a generated file into its header and body, with the hash the
+    header names when it has one. */
+export function splitGenerated(text) {
+    const lines = text.split("\n");
+    let i = 0;
+    while (i < lines.length && lines[i].startsWith("//"))
+        i++;
+    const header = lines.slice(0, i).join("\n");
+    while (i < lines.length && lines[i].trim() === "")
+        i++;
+    const body = lines.slice(i).join("\n");
+    const hash = /schema ([0-9a-f]{12})/.exec(header)?.[1] ?? null;
+    return { header, body, hash };
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@mapled/cli",
+  "version": "0.1.0",
+  "description": "Mapled CLI — sign in, link a project, generate TypeScript types for its content and check the site's integration.",
+  "license": "MIT",
+  "homepage": "https://mapled.io",
+  "keywords": [
+    "mapled",
+    "cms",
+    "headless-cms",
+    "cli",
+    "typescript",
+    "codegen"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "module",
+  "bin": {
+    "mapled": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "prepare": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^3.2.0"
+  }
+}