@seamlet/astro 0.9.0 → 0.10.0

package/README.md

@@ -10,7 +10,19 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
    npm install @seamlet/astro
    ```
 
-2. Describe the content with a schema, and mark the elements that show it:
+2. Name the site in `seamlet.json` at its root: its id in the CMS (lower-case letters, digits and single hyphens; its address there, `/sites/<id>`, the name of its content and the host of its preview), how the CMS names it, and the CMS it belongs to. The CMS reads the same file from the site's repository, so the id is written once.
+
+   ```json
+   {
+     "id": "zerno",
+     "title": "Кофейня «Зерно»",
+     "cms": "https://cms.seamlet.ru"
+   }
+   ```
+
+   The environment variable `CMS_ORIGIN` takes the place of `cms` when it is set: a build for a CMS in development, or the CMS's own builder. A build without the file, or with a field it cannot read, stops and says which field to fix.
+
+3. Describe the content with a schema, and mark the elements that show it:
 
    ```ts
    // src/schema.ts
@@ -46,7 +58,7 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
    <h1 {...edit("title")}>{content.title}</h1>
    ```
 
-3. Describe the site for the CMS: its address and name there, its schema, the content it starts with, and its pages, each with the name the editor gives it and the component that renders it (it takes the content as its `content` prop). The home page `/` comes first; `searchTexts` names where the content holds a page's title and description for search engines, a group of a `title` and a `description` text (`seoFields`).
+4. Describe the site for the CMS in `src/seamlet.ts`: its schema, the content it starts with, and its pages, each with the name the editor gives it and the component that renders it (it takes the content as its `content` prop). The home page `/` comes first; `searchTexts` names where the content holds a page's title and description for search engines, a group of a `title` and a `description` text (`seoFields`).
 
    ```ts
    // src/seamlet.ts
@@ -56,8 +68,6 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
    import { schema } from "./schema";
 
    export default defineSeamletSite({
-     id: "zerno",
-     title: "Кофейня «Зерно»",
      schema,
      initialContent,
      pages: {
@@ -68,20 +78,18 @@ Connects an [Astro](https://astro.build) site to the Seamlet CMS ([source](https
 
    The CMS takes all of it from the site itself, so connecting a site, or changing its schema, needs no change of the CMS.
 
-4. Add the integration:
+5. Add the integration; it reads `seamlet.json` and `src/seamlet.ts` itself:
 
    ```js
    // astro.config.mjs
    import seamlet from "@seamlet/astro";
 
    export default defineConfig({
-     integrations: [
-       seamlet({ cms: "https://cms.example.com", site: "./src/seamlet.ts" }),
-     ],
+     integrations: [seamlet()],
    });
    ```
 
-The site's pages take their published content with `site.loadPublishedContent()`: at build time for a static site, on request otherwise. A module that needs the content without importing every page takes it with `loadPublishedContent(id, schema)` of `@seamlet/astro/site`.
+The site's pages take their published content with `site.loadPublishedContent()`: at build time for a static site, on request otherwise. A module that needs the content without importing every page takes it with `loadPublishedContent(schema)` of `@seamlet/astro/site`.
 
 ## Fields
 
@@ -142,8 +150,6 @@ const MENU_FILES = import.meta.glob<{ default: ImageMetadata }>(
 );
 
 export default defineSeamletSite({
-  id: "zerno",
-  title: "Кофейня «Зерно»",
   schema,
   initialContent,
   pages: { "/": { title: "Главная", component: HomePage } },
@@ -228,7 +234,7 @@ What was opened stays open while the page is rendered anew after every edit.
 
 - `/preview` and `/preview/<page>`: the preview the CMS's editor frames. `GET` shows the published content; `POST` with the content as JSON shows that content without saving it, which is how the editor shows every edit at once. Only the CMS may frame it (`Content-Security-Policy: frame-ancestors`), and it is never indexed or cached.
 - The bridge on the preview: it tells the editor where the marked elements are and what a person does on the page, and types texts in place, formatted ones too.
-- `/seamlet/site.json`: what the site tells the CMS about itself (`SITE_DESCRIPTION_PATH`): its name, its schema, the content it starts with and its pages. The CMS reads it with `readSiteDescription` whenever the site is opened in its editor.
+- `/seamlet/site.json`: what the site tells the CMS about itself (`SITE_DESCRIPTION_PATH`): its id and name from `seamlet.json`, its schema, the content it starts with and its pages. The CMS reads it with `readSiteDescription` whenever the site is opened in its editor.
 - `/seamlet-photos/<address>`: the site's own photo at an address its content gives it, found by `photos` of `defineSeamletSite`, for the CMS's editor.
 - `/media/<site>/<file>`: the photos uploaded in the CMS, taken from it on request; a static build copies every uploaded photo its built pages refer to next to them, so a static host serves them too.
 

package/dist/bridge.js

@@ -18,7 +18,7 @@ import {
   shortcutOf,
   toggleList,
   toggleMark
-} from "./chunk-UBBVOSON.js";
+} from "./chunk-2E7VDSUK.js";
 import {
   FIELD_PATH_ATTRIBUTE,
   REVEALED_ATTRIBUTE,
@@ -27,7 +27,7 @@ import {
   asOneParagraph,
   readRichText,
   resolveFieldPath
-} from "./chunk-NFUGV7JJ.js";
+} from "./chunk-DRDPKFHZ.js";
 
 // src/bridge/typed-fields.ts
 function typedKindAt(schema, path) {

package/dist/{chunk-UBBVOSON.js → chunk-2E7VDSUK.js}

@@ -3,7 +3,7 @@ import {
   normalizedLine,
   readRichText,
   resolveFieldPath
-} from "./chunk-NFUGV7JJ.js";
+} from "./chunk-DRDPKFHZ.js";
 
 // src/bridge/editor-shortcuts.ts
 function shortcutOf(event) {

package/dist/{chunk-NFUGV7JJ.js → chunk-DRDPKFHZ.js}

@@ -917,16 +917,54 @@ function isCount(value) {
   return isNumber(value) && Number.isInteger(value) && value >= 0;
 }
 
+// src/schema/site-config.ts
+var SITE_CONFIG_FILE = "seamlet.json";
+var SITE_ID = /^[a-z0-9]+(-[a-z0-9]+)*$/u;
+var LONGEST_SITE_ID = 63;
+var WEB_PROTOCOLS = /* @__PURE__ */ new Set(["https:", "http:"]);
+var SITE_CONFIG_FIELDS = ["id", "title", "cms"];
+function isSiteId(value) {
+  return typeof value === "string" && value.length <= LONGEST_SITE_ID && SITE_ID.test(value);
+}
+function readSiteConfig(input) {
+  const fields = isRecord3(input) ? input : {};
+  const { id, title } = fields;
+  const cms = originOf(fields["cms"]);
+  const hasId = isSiteId(id);
+  const hasTitle = isText(title);
+  const hasCms = cms !== void 0;
+  if (hasId && hasTitle && hasCms) {
+    return { status: "read", config: { id, title: title.trim(), cms } };
+  }
+  const validity = {
+    id: hasId,
+    title: hasTitle,
+    cms: hasCms
+  };
+  const invalidFields = SITE_CONFIG_FIELDS.filter((field) => !validity[field]);
+  return { status: "invalid", invalidFields };
+}
+function originOf(value) {
+  if (typeof value !== "string" || !URL.canParse(value)) return void 0;
+  const url2 = new URL(value);
+  return WEB_PROTOCOLS.has(url2.protocol) ? url2.origin : void 0;
+}
+function isText(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // src/schema/site-description.ts
 var SITE_DESCRIPTION_PATH = "/seamlet/site.json";
-var SITE_ID = /^[a-z0-9]+(-[a-z0-9]+)*$/u;
 var PAGE_PATH = /^(\/[a-z0-9][a-z0-9-]*)+$/u;
 var HOME_PAGE_PATH = "/";
 function readSiteDescription(input) {
-  if (!isRecord3(input)) return void 0;
+  if (!isRecord4(input)) return void 0;
   const { id, title } = input;
   const schema = readFields(input["schema"]);
-  const isNamed = typeof id === "string" && SITE_ID.test(id) && isText(title);
+  const isNamed = isSiteId(id) && isText2(title);
   if (!isNamed || schema === void 0) return void 0;
   const initial = parseContent(schema, input["initialContent"]);
   const pages = readPages(schema, input["pages"]);
@@ -950,18 +988,18 @@ function readPages(schema, input) {
   return isSound ? [first, ...rest] : void 0;
 }
 function readPage(schema, input) {
-  if (!isRecord3(input)) return void 0;
+  if (!isRecord4(input)) return void 0;
   const { path, title, searchTexts } = input;
   const isPath = typeof path === "string" && (path === HOME_PAGE_PATH || PAGE_PATH.test(path));
-  if (!isPath || !isText(title)) return void 0;
+  if (!isPath || !isText2(title)) return void 0;
   if (searchTexts === void 0) return { path, title };
   const isSearchTexts = typeof searchTexts === "string" && isSearchTextsGroup(schema, searchTexts);
   return isSearchTexts ? { path, title, searchTexts } : void 0;
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isText(value) {
+function isText2(value) {
   return typeof value === "string" && value.trim() !== "";
 }
 
@@ -1012,6 +1050,9 @@ export {
   WEEKDAYS,
   openingHoursField,
   readFields,
+  SITE_CONFIG_FILE,
+  isSiteId,
+  readSiteConfig,
   SITE_DESCRIPTION_PATH,
   readSiteDescription,
   isSearchTextsGroup

package/dist/index.d.ts

@@ -1,11 +1,5 @@
 import { AstroIntegration } from 'astro';
 
-interface SeamletOptions {
-    /** The address of the CMS, such as `https://cms.example.com`. */
-    readonly cms: string;
-    /** The module of the site, relative to the project: `defineSeamletSite(…)` as its default export. */
-    readonly site: string;
-}
-declare function seamlet(options: SeamletOptions): AstroIntegration;
+declare function seamlet(): AstroIntegration;
 
-export { type SeamletOptions, seamlet as default };
+export { seamlet as default };

package/dist/index.js

@@ -2,14 +2,17 @@ import {
   OWN_PHOTOS_PATH
 } from "./chunk-3BS5CE26.js";
 import {
-  SITE_DESCRIPTION_PATH
-} from "./chunk-NFUGV7JJ.js";
+  SITE_CONFIG_FILE,
+  SITE_DESCRIPTION_PATH,
+  readSiteConfig
+} from "./chunk-DRDPKFHZ.js";
 import {
   isUploadedPhoto
 } from "./chunk-P2OQOZBC.js";
 
 // src/index.ts
-import { fileURLToPath } from "url";
+import process from "process";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/uploaded-photos.ts
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
@@ -53,22 +56,78 @@ async function htmlFilesIn(directory) {
   return entries.filter((entry) => entry.isFile() && entry.name.endsWith(HTML_EXTENSION)).map((entry) => join(entry.parentPath, entry.name));
 }
 
+// src/site-config-file.ts
+import { readFile as readFile2 } from "fs/promises";
+import { fileURLToPath } from "url";
+var FIELD_RULES = {
+  id: "the site's id in the CMS: lower-case letters, digits and single hyphens, such as coffee-shop",
+  title: "how the CMS names the site, such as \xAB\u041A\u043E\u0444\u0435\u0439\u043D\u044F \xAB\u0417\u0435\u0440\u043D\u043E\xBB\xBB",
+  cms: "the address of the CMS, such as https://cms.seamlet.ru"
+};
+async function loadSiteConfig(root, cmsOverride) {
+  const file = new URL(SITE_CONFIG_FILE, root);
+  const parsed = await readJsonFile(file);
+  const input = cmsOverride === void 0 ? parsed : { ...asObject(parsed), cms: cmsOverride };
+  const reading = readSiteConfig(input);
+  if (reading.status === "read") return reading.config;
+  throw new Error(invalidFieldsMessage(file, reading.invalidFields));
+}
+async function readJsonFile(file) {
+  let text;
+  try {
+    text = await readFile2(file, "utf8");
+  } catch (error) {
+    throw new Error(
+      `@seamlet/astro: ${fileURLToPath(file)} is missing: the site names its id, its title and its CMS there`,
+      { cause: error }
+    );
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    throw new Error(`@seamlet/astro: ${fileURLToPath(file)} is not JSON`, {
+      cause: error
+    });
+  }
+}
+function asObject(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function invalidFieldsMessage(file, fields) {
+  const lines = fields.map((field) => `  "${field}": ${FIELD_RULES[field]}`);
+  return [
+    `@seamlet/astro: ${fileURLToPath(file)} needs these fields:`,
+    ...lines
+  ].join("\n");
+}
+
 // src/index.ts
 var CONFIG_MODULE = "virtual:seamlet/config";
 var SITE_MODULE = "virtual:seamlet/site";
 var RESOLVED_CONFIG_MODULE = `\0${CONFIG_MODULE}`;
-function seamlet(options) {
-  const cmsOrigin = new URL(options.cms).origin;
+var SITE_MODULE_FILE = "src/seamlet.ts";
+var CMS_ORIGIN_VARIABLE = "CMS_ORIGIN";
+function seamlet() {
+  let siteConfig;
   return {
     name: "@seamlet/astro",
     hooks: {
-      "astro:config:setup": ({
+      "astro:config:setup": async ({
         config,
+        addWatchFile,
         injectRoute,
         injectScript,
         updateConfig
       }) => {
-        const siteModule = fileURLToPath(new URL(options.site, config.root));
+        const loaded = await loadSiteConfig(
+          config.root,
+          process.env[CMS_ORIGIN_VARIABLE]
+        );
+        siteConfig = loaded;
+        addWatchFile(new URL(SITE_CONFIG_FILE, config.root));
+        const siteModule = fileURLToPath2(
+          new URL(SITE_MODULE_FILE, config.root)
+        );
         updateConfig({
           vite: {
             plugins: [
@@ -79,7 +138,7 @@ function seamlet(options) {
                   if (id === SITE_MODULE) return siteModule;
                   return void 0;
                 },
-                load: (id) => id === RESOLVED_CONFIG_MODULE ? `export const cmsOrigin = ${JSON.stringify(cmsOrigin)};` : void 0
+                load: (id) => id === RESOLVED_CONFIG_MODULE ? configModuleOf(loaded) : void 0
               }
             ]
           }
@@ -110,15 +169,23 @@ function seamlet(options) {
       // the built pages refer to are copied next to them. Pages rendered on request take them
       // through the route above.
       "astro:build:done": async ({ dir, logger }) => {
+        if (siteConfig === void 0) return;
         const copied = await copyUploadedPhotos({
-          directory: fileURLToPath(dir),
-          cmsOrigin
+          directory: fileURLToPath2(dir),
+          cmsOrigin: siteConfig.cms
         });
         if (copied > 0) logger.info(`copied ${String(copied)} uploaded photos`);
       }
     }
   };
 }
+function configModuleOf(config) {
+  return [
+    `export const siteId = ${JSON.stringify(config.id)};`,
+    `export const siteTitle = ${JSON.stringify(config.title)};`,
+    `export const cmsOrigin = ${JSON.stringify(config.cms)};`
+  ].join("\n");
+}
 export {
   seamlet as default
 };

package/dist/protocol.js

@@ -22,8 +22,8 @@ import {
   shortcutOf,
   toggleList,
   toggleMark
-} from "./chunk-UBBVOSON.js";
-import "./chunk-NFUGV7JJ.js";
+} from "./chunk-2E7VDSUK.js";
+import "./chunk-DRDPKFHZ.js";
 export {
   OWN_PHOTOS_PATH,
   PROTOCOL_VERSION,

package/dist/schema.d.ts

@@ -175,4 +175,27 @@ declare function openingHoursField(options?: {
 /** The schema the input describes, or undefined when it is not one. */
 declare function readFields(input: unknown): Fields | undefined;
 
-export { ChoicesField, CollectionField, type CollectionRecords, Content, ContentOf, type ContentPath, FIELD_PATH_ATTRIBUTE, Field, type FieldMarker, FieldPath, type FieldTarget, Fields, GroupField, ImageField, ImageValue, LinkField, type LinkKind, type LinkTarget, LinkValue, RECORD_ID_KEY, REVEALED_ATTRIBUTE, REVEAL_ATTRIBUTE, REVEAL_EVENT, RecordFields, TextField, TimeField, UrlField, WEEKDAYS, collectionAt, contactsFields, editable, findRecord, hrefOf, imagePosition, isRecordId, linkTargetOf, newRecord, openingHoursField, readFields, resolveFieldPath, seoFields, withRecordIds };
+/** The file at the root of a site's repository. */
+declare const SITE_CONFIG_FILE = "seamlet.json";
+interface SiteConfig {
+    /** The site's id in the CMS: its address there (`/sites/<id>`) and the name of its content. */
+    readonly id: string;
+    /** How the CMS names the site: «Кофейня «Зерно»». */
+    readonly title: string;
+    /** The origin of the CMS the site belongs to: `https://cms.seamlet.ru`. */
+    readonly cms: string;
+}
+type SiteConfigField = keyof SiteConfig;
+type SiteConfigReading = {
+    readonly status: "read";
+    readonly config: SiteConfig;
+} | {
+    readonly status: "invalid";
+    /** The fields that are missing or not what they must be. */
+    readonly invalidFields: readonly SiteConfigField[];
+};
+declare function isSiteId(value: unknown): value is string;
+/** The config the input gives (the parsed `seamlet.json`); fields it does not know are left out. */
+declare function readSiteConfig(input: unknown): SiteConfigReading;
+
+export { ChoicesField, CollectionField, type CollectionRecords, Content, ContentOf, type ContentPath, FIELD_PATH_ATTRIBUTE, Field, type FieldMarker, FieldPath, type FieldTarget, Fields, GroupField, ImageField, ImageValue, LinkField, type LinkKind, type LinkTarget, LinkValue, RECORD_ID_KEY, REVEALED_ATTRIBUTE, REVEAL_ATTRIBUTE, REVEAL_EVENT, RecordFields, SITE_CONFIG_FILE, type SiteConfig, type SiteConfigField, type SiteConfigReading, TextField, TimeField, UrlField, WEEKDAYS, collectionAt, contactsFields, editable, findRecord, hrefOf, imagePosition, isRecordId, isSiteId, linkTargetOf, newRecord, openingHoursField, readFields, readSiteConfig, resolveFieldPath, seoFields, withRecordIds };

package/dist/schema.js

@@ -4,6 +4,7 @@ import {
   REVEALED_ATTRIBUTE,
   REVEAL_ATTRIBUTE,
   REVEAL_EVENT,
+  SITE_CONFIG_FILE,
   SITE_DESCRIPTION_PATH,
   WEEKDAYS,
   asOneParagraph,
@@ -26,6 +27,7 @@ import {
   imagePosition,
   isRecordId,
   isSearchTextsGroup,
+  isSiteId,
   link,
   linkTargetOf,
   newRecord,
@@ -36,6 +38,7 @@ import {
   plainTextOf,
   readFields,
   readRichText,
+  readSiteConfig,
   readSiteDescription,
   reference,
   references,
@@ -48,13 +51,14 @@ import {
   toggle,
   url,
   withRecordIds
-} from "./chunk-NFUGV7JJ.js";
+} from "./chunk-DRDPKFHZ.js";
 export {
   FIELD_PATH_ATTRIBUTE,
   RECORD_ID_KEY,
   REVEALED_ATTRIBUTE,
   REVEAL_ATTRIBUTE,
   REVEAL_EVENT,
+  SITE_CONFIG_FILE,
   SITE_DESCRIPTION_PATH,
   WEEKDAYS,
   asOneParagraph,
@@ -77,6 +81,7 @@ export {
   imagePosition,
   isRecordId,
   isSearchTextsGroup,
+  isSiteId,
   link,
   linkTargetOf,
   newRecord,
@@ -87,6 +92,7 @@ export {
   plainTextOf,
   readFields,
   readRichText,
+  readSiteConfig,
   readSiteDescription,
   reference,
   references,

package/dist/site.d.ts

@@ -11,11 +11,8 @@ interface SeamletPage {
     /** Where the content holds the page's title and description for search engines (`seo.menu`). */
     readonly searchTexts?: string;
 }
+/** The site's content and pages; its id and title come from `seamlet.json`. */
 interface SeamletSiteDefinition<F extends Fields> {
-    /** The site's address in the CMS: `/sites/<id>`. */
-    readonly id: string;
-    /** How the CMS names the site: «Кофейня «Зерно»». */
-    readonly title: string;
     readonly schema: F;
     /** The content the site shows, and the CMS edits, until the first publication. */
     readonly initialContent: ContentOf<F>;
@@ -42,9 +39,9 @@ interface SeamletSite<F extends Fields = Fields> {
 /** Describes the site for the integration: `src/seamlet.ts` exports it as its default. */
 declare function defineSeamletSite<F extends Fields>(definition: SeamletSiteDefinition<F>): SeamletSite<F>;
 /**
- * What the CMS published for the site with this id, in the shape of its schema: the site's initial
- * content until the first publication. For a module that needs the content without the pages.
+ * What the CMS published for the site, in the shape of its schema: the site's initial content until
+ * the first publication. For a module that needs the content without the pages.
  */
-declare function loadPublishedContent<F extends Fields>(siteId: string, schema: F): Promise<ContentOf<F>>;
+declare function loadPublishedContent<F extends Fields>(schema: F): Promise<ContentOf<F>>;
 
 export { type SeamletPage, type SeamletSite, type SeamletSiteDefinition, defineSeamletSite, loadPublishedContent };

package/dist/site.js

@@ -1,12 +1,12 @@
 import {
   parseContent
-} from "./chunk-NFUGV7JJ.js";
+} from "./chunk-DRDPKFHZ.js";
 
 // src/site.ts
-import { cmsOrigin } from "virtual:seamlet/config";
+import { cmsOrigin, siteId, siteTitle } from "virtual:seamlet/config";
 
 // src/site-descriptions.ts
-function describeSite(definition) {
+function describeSite(identity, definition) {
   const pages = Object.entries(definition.pages).map(
     ([path, page]) => ({
       path,
@@ -16,11 +16,11 @@ function describeSite(definition) {
   );
   const [home, ...rest] = pages;
   if (home === void 0) {
-    throw new Error(`The site "${definition.id}" has no pages`);
+    throw new Error(`The site "${identity.id}" has no pages`);
   }
   return {
-    id: definition.id,
-    title: definition.title,
+    id: identity.id,
+    title: identity.title,
     schema: definition.schema,
     initialContent: definition.initialContent,
     pages: [home, ...rest]
@@ -32,20 +32,20 @@ var HOME_PAGE_PATH = "/";
 function defineSeamletSite(definition) {
   const pages = new Map(Object.entries(definition.pages));
   return {
-    id: definition.id,
+    id: siteId,
     schema: definition.schema,
     pageAt: (rest) => pages.get(rest === void 0 ? HOME_PAGE_PATH : `/${rest}`)?.component,
-    loadPublishedContent: () => loadPublishedContent(definition.id, definition.schema),
+    loadPublishedContent: () => loadPublishedContent(definition.schema),
     ownPhotoAt: (src) => definition.photos?.(src),
-    description: describeSite(definition)
+    description: describeSite({ id: siteId, title: siteTitle }, definition)
   };
 }
-async function loadPublishedContent(siteId, schema) {
+async function loadPublishedContent(schema) {
   const published = await fetchPublished(siteId);
   return parseContent(schema, published).content;
 }
-async function fetchPublished(siteId) {
-  const url = new URL(`/api/sites/${siteId}/published`, cmsOrigin);
+async function fetchPublished(id) {
+  const url = new URL(`/api/sites/${id}/published`, cmsOrigin);
   const response = await fetch(url);
   if (!response.ok) {
     throw new Error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamlet/astro",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Connects an Astro site to the Seamlet CMS: the schema of its content, the preview the editor frames, and its published content.",
   "license": "MIT",
   "type": "module",