@cratis/cast 0.1.0 → 0.2.0

package/writing/fetchWriting.ts

@@ -5,6 +5,7 @@ import type { z } from 'zod';
 import type { writingSourceSchema } from '../config/castSchema';
 import { mergePosts, parseFeed, parseStarlightAuthorPage } from './parse';
 import type { Post, WritingSnapshot } from './WritingSnapshot';
+import { postSchema, writingLimits } from './writingSnapshotSchema';
 
 type WritingSource = z.output<typeof writingSourceSchema>;
 const maximumPages = 10;
@@ -49,6 +50,20 @@ export async function fetchWriting(sources: readonly WritingSource[], warn: (mes
             warn(`writing source ${'rss' in source ? source.rss : source.starlightBlogAuthor}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    if (posts.length === 0) return undefined;
-    return { fetchedAt: new Date().toISOString(), sources: origins, posts: mergePosts(posts) };
+    const kept = withinLimits(posts);
+    if (kept.length === 0) return undefined;
+    return { fetchedAt: new Date().toISOString(), sources: origins.slice(0, writingLimits.sources), posts: kept };
+}
+
+/** Newest posts first, trimmed to the limits a reader of cast.json enforces; posts that would still fail them are left out. */
+export function withinLimits(posts: readonly Post[]): Post[] {
+    return mergePosts(posts)
+        .map(post => ({
+            ...post,
+            title: post.title.slice(0, writingLimits.title),
+            description: post.description.slice(0, writingLimits.description),
+            tags: post.tags.map(tag => tag.slice(0, writingLimits.tag)).slice(0, writingLimits.tags),
+        }))
+        .filter(post => postSchema.safeParse(post).success)
+        .slice(0, writingLimits.posts);
 }

package/writing/writingSnapshotSchema.ts

@@ -0,0 +1,27 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { z } from 'zod';
+import { isInstant } from '../config/calendar';
+
+const instant = z.string().max(64).refine(isInstant, 'Use an ISO 8601 date and time on a real day');
+
+/** The most a writing capture holds; the build that writes one keeps to the same limits. */
+export const writingLimits = { sources: 20, posts: 300, title: 300, description: 2000, tags: 30, tag: 100 } as const;
+
+/** One captured post. */
+export const postSchema = z.object({
+    title: z.string().min(1).max(writingLimits.title),
+    url: z.url({ protocol: /^https?$/ }),
+    date: z.string().max(64).regex(/^\d{4}-\d{2}-\d{2}/, 'Start with YYYY-MM-DD').refine(isInstant, 'Use an ISO 8601 date on a real day'),
+    minutes: z.number().min(0).max(10_000).optional(),
+    description: z.string().max(writingLimits.description).default(''),
+    tags: z.array(z.string().max(writingLimits.tag)).max(writingLimits.tags).default([]),
+});
+
+/** Writing captured from feeds, as it appears in cast.json. */
+export const writingSnapshotSchema = z.object({
+    fetchedAt: instant.optional(),
+    sources: z.array(z.url({ protocol: /^https?$/ })).max(writingLimits.sources).default([]),
+    posts: z.array(postSchema).max(writingLimits.posts).default([]),
+});