@mapled/cli 0.4.0 → 0.5.0

package/dist/doctor.js

@@ -360,6 +360,15 @@ export function checkWebhook(webhook) {
     if (last.status === "pending") {
         return { key: "webhook", label, status: "warning", detail: `The last delivery to ${host} is still pending.` };
     }
+    if (last.error === "blocked") {
+        // Mapled resolved the host to a private address and never connected
+        return {
+            key: "webhook",
+            label,
+            status: "failed",
+            detail: `${host} resolves to a private address, which Mapled can't reach. Point the webhook at the public deployment.`,
+        };
+    }
     const reason = last.responseStatus ? `responded ${last.responseStatus}` : (last.error ?? "failed");
     return {
         key: "webhook",

package/dist/manifest.js

@@ -84,6 +84,7 @@ export const FIELD_TYPE_LABEL = {
     group: "group",
     json: "JSON",
     location: "location",
+    computed: "computed",
 };
 export function typeLabel(type) {
     return FIELD_TYPE_LABEL[type] ?? type;
@@ -241,8 +242,12 @@ export function indexSchema(schema) {
     const index = new Map();
     for (const c of schema.collections) {
         const fields = new Map();
-        for (const f of c.fields)
-            fields.set(f.key, { displayName: f.displayName, type: f.type });
+        // a computed field (§14.9) binds as a field of its result type
+        const COMPUTED_AS = { number: "number", text: "short_text", boolean: "boolean", date: "date", datetime: "datetime" };
+        for (const f of c.fields) {
+            const type = f.type === "computed" && f.computed ? (COMPUTED_AS[f.computed.resultType] ?? f.type) : f.type;
+            fields.set(f.key, { displayName: f.displayName, type });
+        }
         index.set(c.key, { displayName: c.displayName, kind: c.kind, fields });
     }
     return index;

package/dist/pin.js

@@ -104,6 +104,9 @@ function describeType(f, names) {
     if (f.type === "group" && "group" in f && f.group) {
         return `group of ${f.group.fields.length} field${f.group.fields.length === 1 ? "" : "s"}${f.group.repeatable ? ", repeatable" : ""}`;
     }
+    if (f.type === "computed" && "computed" in f && f.computed) {
+        return `computed (${f.computed.resultType === "datetime" ? "date and time" : f.computed.resultType})`;
+    }
     return typeLabel(f.type);
 }
 function diffCommon(before, after, names, push) {
@@ -186,6 +189,14 @@ export function diffSchema(before, after) {
                     push("changed", `on delete ${bf.relation.onDelete ?? "default"} → ${af.relation.onDelete ?? "default"}`, "safe");
                 }
             }
+            if (bf.type === "computed" && af.type === "computed" && bf.computed && af.computed) {
+                if (bf.computed.resultType !== af.computed.resultType) {
+                    push("changed", `${describeType(bf, names)} → ${describeType(af, names)}`, "breaking");
+                }
+                else if (bf.computed.expression !== af.computed.expression) {
+                    push("changed", "formula changed", "safe");
+                }
+            }
             if (bf.type === "group" && af.type === "group" && bf.group && af.group) {
                 if (bf.group.repeatable !== af.group.repeatable) {
                     push("changed", bf.group.repeatable ? "repeatable → single item" : "single item → repeatable", "breaking");

package/dist/schema.d.ts

@@ -31,6 +31,12 @@ export type SchemaField = {
     /** Rules and default (§33) — kept in the schema pin, not read by the generator. */
     validation?: unknown;
     defaultValue?: unknown;
+    /** Computed fields (§14.9): the formula and what it produces — the
+        site reads the value as a field of the result type. */
+    computed?: {
+        expression: string;
+        resultType: string;
+    } | null;
 };
 export type SchemaCollection = {
     key: string;

package/dist/schema.js

@@ -29,6 +29,8 @@ export function schemaHash(schema) {
                     })),
                 }
                 : null,
+            // present only for computed fields, so schemas without formulas hash as before
+            ...(f.type === "computed" && f.computed ? { computed: { expression: f.computed.expression, resultType: f.computed.resultType } } : {}),
         })),
     }));
     return createHash("sha256").update(JSON.stringify(projection)).digest("hex").slice(0, 12);

package/dist/types.js

@@ -94,6 +94,19 @@ function scalarType(type, options) {
             return { type: "unknown", note: type };
     }
 }
+/** The field type a computed field is delivered as (§14.9). */
+const COMPUTED_AS = {
+    number: "number",
+    text: "short_text",
+    boolean: "boolean",
+    date: "date",
+    datetime: "datetime",
+};
+/** What the site receives for a computed field: its result type, read-only. */
+function computedType(resultType) {
+    const base = scalarType(COMPUTED_AS[resultType] ?? "", null);
+    return { type: base.type, note: `computed, ${base.note}` };
+}
 function fieldLine(key, displayName, required, rendered) {
     const doc = `  /** ${comment(displayName)} — ${rendered.note} */`;
     const line = required ? `  ${prop(key)}: ${rendered.type};` : `  ${prop(key)}?: ${rendered.type} | null;`;
@@ -128,6 +141,9 @@ function renderField(field, owner, names, extras) {
             note,
         });
     }
+    if (field.type === "computed" && field.computed) {
+        return fieldLine(field.key, field.displayName, false, computedType(field.computed.resultType));
+    }
     return fieldLine(field.key, field.displayName, field.required, scalarType(field.type, field.options));
 }
 /** Unique type names: the singular PascalCase of the key; the raw

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapled/cli",
-  "version": "0.4.0",
+  "version": "0.5.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",