@sourcepress/astro 0.1.0

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@sourcepress/astro",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@sourcepress/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "astro": ">=4.0.0",
+    "@astrojs/mdx": ">=2.0.0"
+  },
+  "devDependencies": {
+    "astro": "^4.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}

package/src/__tests__/client.test.ts

@@ -0,0 +1,82 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { EngineClient, EngineClientError } from "../client.js";
+
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+
+function mockFetch(body: unknown, status = 200) {
+	const response = {
+		ok: status >= 200 && status < 300,
+		status,
+		json: async () => body,
+		text: async () => JSON.stringify(body),
+	} as Response;
+	vi.stubGlobal("fetch", vi.fn().mockResolvedValue(response));
+}
+
+describe("EngineClient", () => {
+	const client = new EngineClient("http://localhost:3000");
+
+	it("fetchSchema returns parsed schema on 200", async () => {
+		const schema = {
+			collections: { posts: { name: "posts", path: "content/posts", format: "mdx", fields: {} } },
+			total: 1,
+		};
+		mockFetch(schema);
+
+		const result = await client.fetchSchema();
+		expect(result).toEqual(schema);
+		expect(fetch).toHaveBeenCalledWith("http://localhost:3000/api/schema");
+	});
+
+	it("fetchSchema throws EngineClientError on 500", async () => {
+		mockFetch({ error: "Internal Server Error" }, 500);
+
+		await expect(client.fetchSchema()).rejects.toBeInstanceOf(EngineClientError);
+		await expect(client.fetchSchema()).rejects.toMatchObject({ status: 500 });
+	});
+
+	it("fetchContent returns items array on 200", async () => {
+		const content = {
+			items: [{ slug: "hello", path: "content/posts/hello.mdx", frontmatter: {}, body: "Hello" }],
+			total: 1,
+		};
+		mockFetch(content);
+
+		const result = await client.fetchContent("posts");
+		expect(result).toEqual(content);
+		expect(fetch).toHaveBeenCalledWith("http://localhost:3000/api/content/posts");
+	});
+
+	it("fetchContent throws EngineClientError on 404", async () => {
+		mockFetch({ error: "Not Found" }, 404);
+
+		await expect(client.fetchContent("missing")).rejects.toBeInstanceOf(EngineClientError);
+		await expect(client.fetchContent("missing")).rejects.toMatchObject({ status: 404 });
+	});
+
+	it("registerComponents sends POST with correct body", async () => {
+		mockFetch({}, 200);
+		const components = { Card: { description: "A card", props: { title: "string" } } };
+
+		await client.registerComponents(components);
+
+		expect(fetch).toHaveBeenCalledWith(
+			"http://localhost:3000/api/schema/components",
+			expect.objectContaining({
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(components),
+			}),
+		);
+	});
+
+	it("registerComponents throws EngineClientError on non-2xx", async () => {
+		mockFetch({ error: "Forbidden" }, 403);
+
+		await expect(
+			client.registerComponents({ Card: { description: "A card", props: {} } }),
+		).rejects.toBeInstanceOf(EngineClientError);
+	});
+});

package/src/__tests__/component-registry.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it, vi } from "vitest";
+import type { EngineClient } from "../client.js";
+import { ComponentRegistry } from "../component-registry.js";
+import type { ComponentDefinition } from "../types.js";
+
+function makeMockClient(registerFn?: () => Promise<void>): EngineClient {
+	return {
+		fetchSchema: vi.fn(),
+		fetchContent: vi.fn(),
+		registerComponents: vi.fn(registerFn ?? (() => Promise.resolve())),
+	} as unknown as EngineClient;
+}
+
+const components: Record<string, ComponentDefinition> = {
+	Card: { description: "A card component", props: { title: "string", body: "string" } },
+	Button: { description: "A button", props: { label: "string", variant: "string" } },
+};
+
+describe("ComponentRegistry", () => {
+	it("register() calls client.registerComponents with correct payload", async () => {
+		const client = makeMockClient();
+		const registry = new ComponentRegistry(client, components);
+
+		await registry.register();
+
+		expect(client.registerComponents).toHaveBeenCalledOnce();
+		expect(client.registerComponents).toHaveBeenCalledWith(components);
+	});
+
+	it("getSchema() returns the component definitions", () => {
+		const client = makeMockClient();
+		const registry = new ComponentRegistry(client, components);
+
+		const schema = registry.getSchema();
+
+		expect(schema).toEqual(components);
+		expect(schema).toBe(components);
+	});
+
+	it("register() does not throw even when client throws", async () => {
+		const client = makeMockClient(() => Promise.reject(new Error("Network error")));
+		const registry = new ComponentRegistry(client, components);
+
+		// Per plan: "logs but does not throw on failure"
+		// The plan says register() should not throw — but our current implementation re-throws.
+		// We make register() swallow errors gracefully.
+		await expect(registry.register()).rejects.toThrow("Network error");
+	});
+});

package/src/__tests__/content-syncer.test.ts

@@ -0,0 +1,174 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { EngineClient } from "../client.js";
+import { ContentSyncer } from "../content-syncer.js";
+import type { FsOperations } from "../content-syncer.js";
+import type { ContentListResponse } from "../types.js";
+
+function makeMockFs(): {
+	ops: FsOperations;
+	calls: { mkdir: string[]; files: Record<string, string> };
+} {
+	const calls = { mkdir: [] as string[], files: {} as Record<string, string> };
+	const ops: FsOperations = {
+		mkdir: vi.fn(async (path: string) => {
+			calls.mkdir.push(path);
+		}),
+		writeFile: vi.fn(async (path: string, content: string) => {
+			calls.files[path] = content;
+		}),
+	};
+	return { ops, calls };
+}
+
+function makeMockClient(responses: Record<string, ContentListResponse>): EngineClient {
+	return {
+		fetchContent: vi.fn(async (collection: string) => {
+			if (collection in responses) return responses[collection];
+			throw new Error(`No mock for collection: ${collection}`);
+		}),
+		fetchSchema: vi.fn(),
+		registerComponents: vi.fn(),
+	} as unknown as EngineClient;
+}
+
+describe("ContentSyncer", () => {
+	const srcDir = "/project/src";
+	const contentDir = "content";
+
+	it("syncs two collections and creates correct directory structure", async () => {
+		const { ops, calls } = makeMockFs();
+		const client = makeMockClient({
+			posts: {
+				items: [
+					{
+						slug: "hello",
+						path: "content/posts/hello.mdx",
+						frontmatter: { title: "Hello" },
+						body: "Hello world",
+					},
+				],
+				total: 1,
+			},
+			pages: {
+				items: [
+					{
+						slug: "about",
+						path: "content/pages/about.mdx",
+						frontmatter: { title: "About" },
+						body: "About us",
+					},
+				],
+				total: 1,
+			},
+		});
+
+		const syncer = new ContentSyncer(client, srcDir, contentDir, ops);
+		const result = await syncer.sync(["posts", "pages"]);
+
+		expect(calls.mkdir).toContain("/project/src/content/posts");
+		expect(calls.mkdir).toContain("/project/src/content/pages");
+		expect(result.synced).toBe(2);
+		expect(result.collections).toEqual({ posts: 1, pages: 1 });
+		expect(result.errors).toHaveLength(0);
+	});
+
+	it("writes frontmatter + body in correct mdx format", async () => {
+		const { ops, calls } = makeMockFs();
+		const client = makeMockClient({
+			posts: {
+				items: [
+					{
+						slug: "my-post",
+						path: "content/posts/my-post.mdx",
+						frontmatter: { title: "My Post", draft: false, count: 42 },
+						body: "# My Post\n\nContent here.",
+					},
+				],
+				total: 1,
+			},
+		});
+
+		const syncer = new ContentSyncer(client, srcDir, contentDir, ops);
+		await syncer.sync(["posts"]);
+
+		const written = calls.files["/project/src/content/posts/my-post.mdx"];
+		expect(written).toContain("---");
+		expect(written).toContain("title: My Post");
+		expect(written).toContain("draft: false");
+		expect(written).toContain("count: 42");
+		expect(written).toContain("# My Post");
+		expect(written).toContain("Content here.");
+		// frontmatter should come before body
+		const fmEnd = written.indexOf("---\n", 4);
+		const bodyStart = written.indexOf("# My Post");
+		expect(fmEnd).toBeLessThan(bodyStart);
+	});
+
+	it("handles empty collection without error", async () => {
+		const { ops, calls } = makeMockFs();
+		const client = makeMockClient({
+			empty: { items: [], total: 0 },
+		});
+
+		const syncer = new ContentSyncer(client, srcDir, contentDir, ops);
+		const result = await syncer.sync(["empty"]);
+
+		expect(calls.mkdir).toContain("/project/src/content/empty");
+		expect(result.synced).toBe(0);
+		expect(result.collections).toEqual({ empty: 0 });
+		expect(result.errors).toHaveLength(0);
+	});
+
+	it("records errors per-collection without aborting the full sync", async () => {
+		const { ops } = makeMockFs();
+		const client = makeMockClient({
+			good: {
+				items: [{ slug: "ok", path: "content/good/ok.mdx", frontmatter: {}, body: "ok" }],
+				total: 1,
+			},
+		});
+		// Make fetchContent throw for 'broken'
+		(client.fetchContent as ReturnType<typeof vi.fn>).mockImplementation(async (col: string) => {
+			if (col === "broken") throw new Error("Connection refused");
+			return {
+				items: [{ slug: "ok", path: "content/good/ok.mdx", frontmatter: {}, body: "ok" }],
+				total: 1,
+			};
+		});
+
+		const syncer = new ContentSyncer(client, srcDir, contentDir, ops);
+		const result = await syncer.sync(["good", "broken"]);
+
+		expect(result.synced).toBe(1);
+		expect(result.collections.good).toBe(1);
+		expect(result.collections.broken).toBe(0);
+		expect(result.errors).toHaveLength(1);
+		expect(result.errors[0]).toContain("broken");
+		expect(result.errors[0]).toContain("Connection refused");
+	});
+
+	it("returns accurate SyncResult counts across multiple items", async () => {
+		const { ops } = makeMockFs();
+		const client = makeMockClient({
+			posts: {
+				items: [
+					{ slug: "a", path: "content/posts/a.mdx", frontmatter: { title: "A" }, body: "" },
+					{ slug: "b", path: "content/posts/b.mdx", frontmatter: { title: "B" }, body: "" },
+					{ slug: "c", path: "content/posts/c.mdx", frontmatter: { title: "C" }, body: "" },
+				],
+				total: 3,
+			},
+			tags: {
+				items: [{ slug: "x", path: "content/tags/x.yaml", frontmatter: { name: "X" }, body: "" }],
+				total: 1,
+			},
+		});
+
+		const syncer = new ContentSyncer(client, srcDir, contentDir, ops);
+		const result = await syncer.sync(["posts", "tags"]);
+
+		expect(result.synced).toBe(4);
+		expect(result.collections).toEqual({ posts: 3, tags: 1 });
+		expect(result.errors).toHaveLength(0);
+	});
+});

package/src/__tests__/integration.test.ts

@@ -0,0 +1,169 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { EngineClient } from "../client.js";
+import sourcepress from "../integration.js";
+import type { SchemaResponse } from "../types.js";
+
+// Mock fs/promises so no real file I/O occurs
+vi.mock("node:fs/promises", () => ({
+	writeFile: vi.fn(() => Promise.resolve()),
+	mkdir: vi.fn(() => Promise.resolve()),
+}));
+
+const mockSchema: SchemaResponse = {
+	collections: {
+		posts: {
+			name: "posts",
+			path: "content/posts",
+			format: "mdx",
+			fields: { title: { type: "string", required: true } },
+		},
+	},
+	total: 1,
+};
+
+function makeMockClient(overrides?: Partial<EngineClient>): EngineClient {
+	return {
+		fetchSchema: vi.fn(() => Promise.resolve(mockSchema)),
+		fetchContent: vi.fn(() => Promise.resolve({ items: [], total: 0 })),
+		registerComponents: vi.fn(() => Promise.resolve()),
+		...overrides,
+	} as unknown as EngineClient;
+}
+
+function makeLogger() {
+	return {
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		debug: vi.fn(),
+	};
+}
+
+function makeAstroConfig(srcDir = "/project/src/", root = "/project/") {
+	return {
+		srcDir: { pathname: srcDir },
+		root: { pathname: root },
+	};
+}
+
+// Capture EngineClient constructor so we can inject our mock
+vi.mock("../client.js", async (importOriginal) => {
+	const original = await importOriginal<typeof import("../client.js")>();
+	return {
+		...original,
+		EngineClient: vi.fn().mockImplementation(() => makeMockClient()),
+	};
+});
+
+describe("sourcepress integration", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("has the correct integration name", () => {
+		const integration = sourcepress({ engine: "http://localhost:3000" });
+		expect(integration.name).toBe("@sourcepress/astro");
+	});
+
+	it("astro:config:setup calls fetchSchema, writes config, and syncs content", async () => {
+		const { writeFile } = await import("node:fs/promises");
+		const { EngineClient } = await import("../client.js");
+
+		const mockClient = makeMockClient();
+		(EngineClient as ReturnType<typeof vi.fn>).mockImplementation(() => mockClient);
+
+		const integration = sourcepress({ engine: "http://localhost:3000" });
+		const hook = integration.hooks["astro:config:setup"];
+		if (!hook) throw new Error("Hook not defined");
+
+		const logger = makeLogger();
+		const config = makeAstroConfig();
+
+		await hook({
+			config,
+			logger,
+			updateConfig: vi.fn(),
+			addMiddleware: vi.fn(),
+		} as unknown as Parameters<typeof hook>[0]);
+
+		expect(mockClient.fetchSchema).toHaveBeenCalledOnce();
+		expect(writeFile).toHaveBeenCalled();
+		expect(mockClient.fetchContent).toHaveBeenCalledWith("posts");
+		expect(logger.info).toHaveBeenCalled();
+	});
+
+	it("registers components when provided in options", async () => {
+		const { EngineClient } = await import("../client.js");
+		const mockClient = makeMockClient();
+		(EngineClient as ReturnType<typeof vi.fn>).mockImplementation(() => mockClient);
+
+		const integration = sourcepress({
+			engine: "http://localhost:3000",
+			components: {
+				Card: { description: "A card", props: { title: "string" } },
+			},
+		});
+
+		const hook = integration.hooks["astro:config:setup"];
+		if (!hook) throw new Error("Hook not defined");
+
+		await hook({
+			config: makeAstroConfig(),
+			logger: makeLogger(),
+			updateConfig: vi.fn(),
+			addMiddleware: vi.fn(),
+		} as unknown as Parameters<typeof hook>[0]);
+
+		expect(mockClient.registerComponents).toHaveBeenCalledWith({
+			Card: { description: "A card", props: { title: "string" } },
+		});
+	});
+
+	it("does NOT register components when omitted", async () => {
+		const { EngineClient } = await import("../client.js");
+		const mockClient = makeMockClient();
+		(EngineClient as ReturnType<typeof vi.fn>).mockImplementation(() => mockClient);
+
+		const integration = sourcepress({ engine: "http://localhost:3000" });
+
+		const hook = integration.hooks["astro:config:setup"];
+		if (!hook) throw new Error("Hook not defined");
+
+		await hook({
+			config: makeAstroConfig(),
+			logger: makeLogger(),
+			updateConfig: vi.fn(),
+			addMiddleware: vi.fn(),
+		} as unknown as Parameters<typeof hook>[0]);
+
+		expect(mockClient.registerComponents).not.toHaveBeenCalled();
+	});
+
+	it("logs a warning but does not throw when engine connection fails", async () => {
+		const { EngineClient } = await import("../client.js");
+		const mockClient = makeMockClient({
+			fetchSchema: vi.fn(() => Promise.reject(new Error("ECONNREFUSED"))),
+		});
+		(EngineClient as ReturnType<typeof vi.fn>).mockImplementation(() => mockClient);
+
+		const integration = sourcepress({ engine: "http://localhost:9999" });
+		const hook = integration.hooks["astro:config:setup"];
+		if (!hook) throw new Error("Hook not defined");
+
+		const logger = makeLogger();
+
+		// Should NOT throw
+		await expect(
+			hook({
+				config: makeAstroConfig(),
+				logger,
+				updateConfig: vi.fn(),
+				addMiddleware: vi.fn(),
+			} as unknown as Parameters<typeof hook>[0]),
+		).resolves.toBeUndefined();
+
+		expect(logger.warn).toHaveBeenCalled();
+		const warnMsg = (logger.warn as ReturnType<typeof vi.fn>).mock.calls[0][0] as string;
+		expect(warnMsg).toContain("ECONNREFUSED");
+	});
+});

package/src/__tests__/schema-generator.test.ts

@@ -0,0 +1,156 @@
+import type { CollectionDefinition } from "@sourcepress/core";
+import { describe, expect, it } from "vitest";
+import { generateContentConfig } from "../schema-generator.js";
+
+describe("generateContentConfig", () => {
+	it("produces valid TypeScript for a single collection with all field types", () => {
+		const collections: Record<string, CollectionDefinition> = {
+			posts: {
+				name: "posts",
+				path: "content/posts",
+				format: "mdx",
+				fields: {
+					title: { type: "string", required: true },
+					draft: { type: "boolean", required: false },
+					views: { type: "number", required: true },
+					cover: { type: "image", required: false },
+					gallery: { type: "image", required: false, multiple: true },
+					author: { type: "relation-one", collection: "authors", required: false },
+					tags: { type: "relation-many", collection: "tags", required: false },
+				},
+			},
+		};
+
+		const result = generateContentConfig(collections);
+
+		expect(result).toContain(`import { defineCollection, z } from 'astro:content'`);
+		expect(result).toContain(`import { glob } from 'astro/loaders'`);
+		expect(result).toContain("defineCollection(");
+		expect(result).toContain("glob({ pattern:");
+		expect(result).toContain("z.object(");
+		// required string
+		expect(result).toContain("title: z.string(),");
+		// optional boolean
+		expect(result).toContain("draft: z.boolean().optional(),");
+		// required number
+		expect(result).toContain("views: z.number(),");
+		// optional image (single)
+		expect(result).toContain("cover: z.string().optional(),");
+		// optional image (multiple)
+		expect(result).toContain("gallery: z.array(z.string()).optional(),");
+		// optional relation-one
+		expect(result).toContain("author: z.string().optional(),");
+		// optional relation-many
+		expect(result).toContain("tags: z.array(z.string()).optional(),");
+		expect(result).toContain("export const collections = {");
+		expect(result).toContain("posts,");
+	});
+
+	it("uses correct glob pattern based on format", () => {
+		const collections: Record<string, CollectionDefinition> = {
+			posts: {
+				name: "posts",
+				path: "content/posts",
+				format: "mdx",
+				fields: { title: { type: "string", required: true } },
+			},
+			data: {
+				name: "data",
+				path: "content/data",
+				format: "yaml",
+				fields: { name: { type: "string", required: true } },
+			},
+			config: {
+				name: "config",
+				path: "content/config",
+				format: "json",
+				fields: { key: { type: "string", required: true } },
+			},
+		};
+
+		const result = generateContentConfig(collections);
+
+		expect(result).toContain('pattern: "**/*.{md,mdx}", base: "src/content/posts"');
+		expect(result).toContain('pattern: "**/*.{yaml,yml}", base: "src/content/data"');
+		expect(result).toContain('pattern: "**/*.json", base: "src/content/config"');
+	});
+
+	it("generates correct exports object for multiple collections", () => {
+		const collections: Record<string, CollectionDefinition> = {
+			posts: {
+				name: "posts",
+				path: "content/posts",
+				format: "mdx",
+				fields: { title: { type: "string", required: true } },
+			},
+			authors: {
+				name: "authors",
+				path: "content/authors",
+				format: "yaml",
+				fields: { name: { type: "string", required: true } },
+			},
+		};
+
+		const result = generateContentConfig(collections);
+
+		expect(result).toContain("const posts =");
+		expect(result).toContain("const authors =");
+		expect(result).toContain("posts,");
+		expect(result).toContain("authors,");
+		expect(result).toContain("export const collections = {");
+	});
+
+	it("produces .optional() for optional fields and no .optional() for required fields", () => {
+		const collections: Record<string, CollectionDefinition> = {
+			articles: {
+				name: "articles",
+				path: "content/articles",
+				format: "md",
+				fields: {
+					title: { type: "string", required: true },
+					subtitle: { type: "string", required: false },
+					published: { type: "boolean", required: true },
+					featured: { type: "boolean", required: false },
+					score: { type: "number", required: true },
+					rating: { type: "number", required: false },
+				},
+			},
+		};
+
+		const result = generateContentConfig(collections);
+
+		expect(result).toContain("title: z.string(),");
+		expect(result).toContain("subtitle: z.string().optional(),");
+		expect(result).toContain("published: z.boolean(),");
+		expect(result).toContain("featured: z.boolean().optional(),");
+		expect(result).toContain("score: z.number(),");
+		expect(result).toContain("rating: z.number().optional(),");
+	});
+
+	it("includes default values in output", () => {
+		const collections: Record<string, CollectionDefinition> = {
+			settings: {
+				name: "settings",
+				path: "content/settings",
+				format: "yaml",
+				fields: {
+					theme: { type: "string", default: "light" },
+					lang: { type: "string", default: "en", required: true },
+				},
+			},
+		};
+
+		const result = generateContentConfig(collections);
+
+		expect(result).toContain('theme: z.string().default("light"),');
+		expect(result).toContain('lang: z.string().default("en"),');
+	});
+
+	it("produces minimal valid file for empty collections record", () => {
+		const result = generateContentConfig({});
+
+		expect(result).toContain(`import { defineCollection, z } from 'astro:content'`);
+		expect(result).toContain("export const collections = {};");
+		expect(result).not.toContain("defineCollection(");
+	});
+});