emdash 0.0.0-a → 0.0.1

package/src/astro/routes/api/schema/collections/[slug]/fields/[fieldSlug].ts

@@ -0,0 +1,76 @@
+/**
+ * Schema field CRUD endpoints
+ *
+ * GET    /_emdash/api/schema/collections/{slug}/fields/{fieldSlug} - Get field
+ * PUT    /_emdash/api/schema/collections/{slug}/fields/{fieldSlug} - Update field
+ * DELETE /_emdash/api/schema/collections/{slug}/fields/{fieldSlug} - Delete field
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import {
+	handleSchemaFieldGet,
+	handleSchemaFieldUpdate,
+	handleSchemaFieldDelete,
+} from "#api/index.js";
+import { parseBody, isParseError } from "#api/parse.js";
+import { updateFieldBody } from "#api/schemas.js";
+import type { UpdateFieldInput } from "#schema/types.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const collectionSlug = params.slug!;
+	const fieldSlug = params.fieldSlug!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:read");
+	if (denied) return denied;
+
+	const result = await handleSchemaFieldGet(emdash!.db, collectionSlug, fieldSlug);
+	return unwrapResult(result);
+};
+
+export const PUT: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const collectionSlug = params.slug!;
+	const fieldSlug = params.fieldSlug!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const body = await parseBody(request, updateFieldBody);
+	if (isParseError(body)) return body;
+
+	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- body is Zod-validated via parseBody(request, updateFieldBody) above
+	const result = await handleSchemaFieldUpdate(
+		emdash!.db,
+		collectionSlug,
+		fieldSlug,
+		body as UpdateFieldInput,
+	);
+	return unwrapResult(result);
+};
+
+export const DELETE: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const collectionSlug = params.slug!;
+	const fieldSlug = params.fieldSlug!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const result = await handleSchemaFieldDelete(emdash!.db, collectionSlug, fieldSlug);
+	return unwrapResult(result);
+};

package/src/astro/routes/api/schema/collections/[slug]/fields/index.ts

@@ -0,0 +1,52 @@
+/**
+ * Schema fields list and create endpoints
+ *
+ * GET  /_emdash/api/schema/collections/{slug}/fields - List fields
+ * POST /_emdash/api/schema/collections/{slug}/fields - Create field
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleSchemaFieldList, handleSchemaFieldCreate } from "#api/index.js";
+import { parseBody, isParseError } from "#api/parse.js";
+import { createFieldBody } from "#api/schemas.js";
+import type { CreateFieldInput } from "#schema/types.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const collectionSlug = params.slug!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:read");
+	if (denied) return denied;
+
+	const result = await handleSchemaFieldList(emdash!.db, collectionSlug);
+	return unwrapResult(result);
+};
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const collectionSlug = params.slug!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const body = await parseBody(request, createFieldBody);
+	if (isParseError(body)) return body;
+
+	const result = await handleSchemaFieldCreate(
+		emdash!.db,
+		collectionSlug,
+		body as CreateFieldInput,
+	);
+	return unwrapResult(result, 201);
+};

package/src/astro/routes/api/schema/collections/[slug]/fields/reorder.ts

@@ -0,0 +1,32 @@
+/**
+ * Schema field reorder endpoint
+ *
+ * POST /_emdash/api/schema/collections/{slug}/fields/reorder - Reorder fields
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleSchemaFieldReorder } from "#api/index.js";
+import { parseBody, isParseError } from "#api/parse.js";
+import { fieldReorderBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const collectionSlug = params.slug!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const body = await parseBody(request, fieldReorderBody);
+	if (isParseError(body)) return body;
+
+	const result = await handleSchemaFieldReorder(emdash!.db, collectionSlug, body.fieldSlugs);
+	return unwrapResult(result);
+};

package/src/astro/routes/api/schema/collections/[slug]/index.ts

@@ -0,0 +1,80 @@
+/**
+ * Schema collection CRUD endpoints
+ *
+ * GET    /_emdash/api/schema/collections/{slug} - Get collection
+ * PUT    /_emdash/api/schema/collections/{slug} - Update collection
+ * DELETE /_emdash/api/schema/collections/{slug} - Delete collection
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import {
+	handleSchemaCollectionGet,
+	handleSchemaCollectionUpdate,
+	handleSchemaCollectionDelete,
+} from "#api/index.js";
+import { parseBody, parseQuery, isParseError } from "#api/parse.js";
+import { collectionGetQuery, updateCollectionBody } from "#api/schemas.js";
+import type { UpdateCollectionInput } from "#schema/types.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, url, locals }) => {
+	const { emdash, user } = locals;
+	const slug = params.slug!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:read");
+	if (denied) return denied;
+
+	const query = parseQuery(url, collectionGetQuery);
+	if (isParseError(query)) return query;
+
+	const result = await handleSchemaCollectionGet(emdash!.db, slug, {
+		includeFields: query.includeFields ?? false,
+	});
+	return unwrapResult(result);
+};
+
+export const PUT: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const slug = params.slug!;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const body = await parseBody(request, updateCollectionBody);
+	if (isParseError(body)) return body;
+
+	const result = await handleSchemaCollectionUpdate(
+		emdash!.db,
+		slug,
+		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- parseBody validates via Zod
+		body as UpdateCollectionInput,
+	);
+	return unwrapResult(result);
+};
+
+export const DELETE: APIRoute = async ({ params, url, locals }) => {
+	const { emdash, user } = locals;
+	const slug = params.slug!;
+	const force = url.searchParams.get("force") === "true";
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const result = await handleSchemaCollectionDelete(emdash!.db, slug, {
+		force,
+	});
+	return unwrapResult(result);
+};

package/src/astro/routes/api/schema/collections/index.ts

@@ -0,0 +1,47 @@
+/**
+ * Schema collections list and create endpoints
+ *
+ * GET  /_emdash/api/schema/collections - List collections
+ * POST /_emdash/api/schema/collections - Create collection
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleSchemaCollectionList, handleSchemaCollectionCreate } from "#api/index.js";
+import { parseBody, isParseError } from "#api/parse.js";
+import { createCollectionBody } from "#api/schemas.js";
+import type { CreateCollectionInput } from "#schema/types.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:read");
+	if (denied) return denied;
+
+	const result = await handleSchemaCollectionList(emdash!.db);
+	return unwrapResult(result);
+};
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const body = await parseBody(request, createCollectionBody);
+	if (isParseError(body)) return body;
+
+	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Zod schema output narrowed to CreateCollectionInput
+	const result = await handleSchemaCollectionCreate(emdash!.db, body as CreateCollectionInput);
+	return unwrapResult(result, 201);
+};

package/src/astro/routes/api/schema/index.ts

@@ -0,0 +1,109 @@
+/**
+ * Schema export endpoint for CLI sync
+ *
+ * GET /_emdash/api/schema - Export full schema (requires schema:read permission)
+ *
+ * This endpoint is used by:
+ * - CLI `emdash types` to fetch schema and generate types
+ * - Local dev server to sync schema from remote
+ * - CI/CD to detect schema drift
+ */
+
+import type { APIRoute } from "astro";
+import { hashString } from "emdash";
+
+import { requirePerm } from "#api/authorize.js";
+import { handleError, requireDb } from "#api/error.js";
+import { SchemaRegistry } from "#schema/registry.js";
+import { generateTypeScript } from "#schema/zod-generator.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:read");
+	if (denied) return denied;
+
+	try {
+		const registry = new SchemaRegistry(emdash!.db);
+
+		// Get all collections with their fields
+		const collections = await registry.listCollections();
+		const collectionsWithFields = await Promise.all(
+			collections.map(async (c) => {
+				const fields = await registry.listFields(c.id);
+				return { ...c, fields };
+			}),
+		);
+
+		// Check for format parameter
+		const url = new URL(request.url);
+		const format = url.searchParams.get("format");
+
+		if (format === "typescript") {
+			// Generate TypeScript definitions
+			const types = collectionsWithFields.map((c) => generateTypeScript(c)).join("\n\n");
+
+			const header = `// Generated by EmDash CLI
+// Do not edit manually - run \`emdash types\` to regenerate
+
+import type { PortableTextBlock } from "emdash";
+
+`;
+
+			return new Response(header + types, {
+				status: 200,
+				headers: {
+					"Content-Type": "text/typescript",
+					"Cache-Control": "private, no-store",
+				},
+			});
+		}
+
+		// Default: JSON format
+		const schemaExport = {
+			collections: collectionsWithFields.map((c) => ({
+				slug: c.slug,
+				label: c.label,
+				labelSingular: c.labelSingular,
+				description: c.description,
+				icon: c.icon,
+				supports: c.supports,
+				fields: c.fields.map((f) => ({
+					slug: f.slug,
+					label: f.label,
+					type: f.type,
+					required: f.required,
+					unique: f.unique,
+					defaultValue: f.defaultValue,
+					validation: f.validation,
+					widget: f.widget,
+					options: f.options,
+				})),
+			})),
+		};
+
+		const version = await hashString(JSON.stringify(schemaExport));
+
+		return new Response(
+			JSON.stringify({
+				...schemaExport,
+				version,
+			}),
+			{
+				status: 200,
+				headers: {
+					"Content-Type": "application/json",
+					"Cache-Control": "private, no-store",
+					"X-Schema-Version": version,
+				},
+			},
+		);
+	} catch (error) {
+		return handleError(error, "Schema export failed", "SCHEMA_EXPORT_ERROR");
+	}
+};

package/src/astro/routes/api/schema/orphans/[slug].ts

@@ -0,0 +1,36 @@
+/**
+ * Register orphaned table endpoint
+ *
+ * POST /_emdash/api/schema/orphans/:slug - Register an orphaned table as a collection
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, requireDb, unwrapResult } from "#api/error.js";
+import { handleOrphanedTableRegister } from "#api/index.js";
+import { parseOptionalBody, isParseError } from "#api/parse.js";
+import { orphanRegisterBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const slug = params.slug;
+	if (!slug) {
+		return apiError("VALIDATION_ERROR", "Slug is required", 400);
+	}
+
+	const options = await parseOptionalBody(request, orphanRegisterBody, {});
+	if (isParseError(options)) return options;
+
+	const result = await handleOrphanedTableRegister(emdash!.db, slug, options);
+	return unwrapResult(result, 201);
+};

package/src/astro/routes/api/schema/orphans/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Orphaned tables discovery endpoint
+ *
+ * GET  /_emdash/api/schema/orphans - List orphaned content tables
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleOrphanedTableList } from "#api/index.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ locals }) => {
+	const { emdash, user } = locals;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const result = await handleOrphanedTableList(emdash!.db);
+	return unwrapResult(result);
+};

package/src/astro/routes/api/search/enable.ts

@@ -0,0 +1,64 @@
+/**
+ * Search enable/disable endpoint
+ *
+ * POST /_emdash/api/search/enable
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { searchEnableBody } from "#api/schemas.js";
+import { FTSManager } from "#search/index.js";
+
+export const prerender = false;
+
+/**
+ * Enable or disable search for a collection
+ *
+ * Body:
+ * - collection: Collection slug (required)
+ * - enabled: boolean (required)
+ * - weights: Optional field weights for ranking
+ */
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash not configured", 500);
+	}
+
+	const denied = requirePerm(user, "search:manage");
+	if (denied) return denied;
+
+	const body = await parseBody(request, searchEnableBody);
+	if (isParseError(body)) return body;
+
+	const ftsManager = new FTSManager(emdash.db);
+
+	try {
+		if (body.enabled) {
+			// Enable search - creates FTS table, triggers, and populates index
+			await ftsManager.enableSearch(body.collection, { weights: body.weights });
+
+			const stats = await ftsManager.getIndexStats(body.collection);
+
+			return apiSuccess({
+				collection: body.collection,
+				enabled: true,
+				indexed: stats?.indexed ?? 0,
+			});
+		} else {
+			// Disable search - drops FTS table and triggers
+			await ftsManager.disableSearch(body.collection);
+
+			return apiSuccess({
+				collection: body.collection,
+				enabled: false,
+			});
+		}
+	} catch (error) {
+		return handleError(error, "Failed to update search config", "SEARCH_ERROR");
+	}
+};

package/src/astro/routes/api/search/index.ts

@@ -0,0 +1,55 @@
+/**
+ * Search endpoint - Full-text search across collections
+ *
+ * GET /_emdash/api/search?q=query&collections=posts,pages&limit=20
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { isParseError, parseQuery } from "#api/parse.js";
+import { searchQuery } from "#api/schemas.js";
+import { searchWithDb } from "#search/index.js";
+
+export const prerender = false;
+
+/**
+ * Search content
+ *
+ * Query parameters:
+ * - q: Search query (required)
+ * - collections: Comma-separated list of collection slugs (optional, defaults to all)
+ * - status: Filter by status (optional, defaults to 'published')
+ * - limit: Maximum results (optional, defaults to 20)
+ */
+export const GET: APIRoute = async ({ url, locals }) => {
+	const { emdash, user } = locals;
+
+	const denied = requirePerm(user, "search:read");
+	if (denied) return denied;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash not configured", 500);
+	}
+
+	const query = parseQuery(url, searchQuery);
+	if (isParseError(query)) return query;
+
+	const collections = query.collections
+		? query.collections.split(",").map((c: string) => c.trim())
+		: undefined;
+
+	try {
+		const result = await searchWithDb(emdash.db, query.q, {
+			collections,
+			status: query.status,
+			locale: query.locale,
+			limit: query.limit,
+		});
+
+		return apiSuccess(result);
+	} catch (error) {
+		return handleError(error, "Search failed", "SEARCH_ERROR");
+	}
+};

package/src/astro/routes/api/search/rebuild.ts

@@ -0,0 +1,72 @@
+/**
+ * Search rebuild endpoint - Rebuild FTS index
+ *
+ * POST /_emdash/api/search/rebuild
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { searchRebuildBody } from "#api/schemas.js";
+import { FTSManager } from "#search/index.js";
+
+export const prerender = false;
+
+/**
+ * Rebuild the search index for a collection
+ *
+ * Body:
+ * - collection: Collection slug to rebuild (required)
+ */
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash not configured", 500);
+	}
+
+	const denied = requirePerm(user, "search:manage");
+	if (denied) return denied;
+
+	const body = await parseBody(request, searchRebuildBody);
+	if (isParseError(body)) return body;
+
+	const ftsManager = new FTSManager(emdash.db);
+
+	try {
+		// Get search config for the collection
+		const config = await ftsManager.getSearchConfig(body.collection);
+		if (!config?.enabled) {
+			return apiError(
+				"SEARCH_NOT_ENABLED",
+				`Search is not enabled for collection "${body.collection}"`,
+				400,
+			);
+		}
+
+		// Get searchable fields
+		const searchableFields = await ftsManager.getSearchableFields(body.collection);
+		if (searchableFields.length === 0) {
+			return apiError(
+				"NO_SEARCHABLE_FIELDS",
+				`No searchable fields defined for collection "${body.collection}"`,
+				400,
+			);
+		}
+
+		// Rebuild the index
+		await ftsManager.rebuildIndex(body.collection, searchableFields, config.weights);
+
+		// Get stats after rebuild
+		const stats = await ftsManager.getIndexStats(body.collection);
+
+		return apiSuccess({
+			collection: body.collection,
+			indexed: stats?.indexed ?? 0,
+		});
+	} catch (error) {
+		return handleError(error, "Failed to rebuild index", "REBUILD_ERROR");
+	}
+};

package/src/astro/routes/api/search/stats.ts

@@ -0,0 +1,35 @@
+/**
+ * Search stats endpoint
+ *
+ * GET /_emdash/api/search/stats
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { getSearchStats } from "#search/index.js";
+
+export const prerender = false;
+
+/**
+ * Get search index statistics
+ */
+export const GET: APIRoute = async ({ locals }) => {
+	const { emdash, user } = locals;
+
+	const denied = requirePerm(user, "search:manage");
+	if (denied) return denied;
+
+	if (!emdash?.db) {
+		return apiError("NOT_CONFIGURED", "EmDash not configured", 500);
+	}
+
+	try {
+		const stats = await getSearchStats(emdash.db);
+
+		return apiSuccess(stats);
+	} catch (error) {
+		return handleError(error, "Failed to get stats", "STATS_ERROR");
+	}
+};