emdash 0.0.0-a → 0.0.1

package/src/api/schemas/schema.ts

@@ -0,0 +1,203 @@
+import { z } from "zod";
+
+import { slugPattern } from "./common.js";
+
+// ---------------------------------------------------------------------------
+// Schema (collections & fields): Input schemas
+// ---------------------------------------------------------------------------
+
+const collectionSupportValues = z.enum(["drafts", "revisions", "preview", "scheduling", "search"]);
+
+const collectionSourcePattern = /^(template:.+|import:.+|manual|discovered|seed)$/;
+
+const fieldTypeValues = z.enum([
+	"string",
+	"text",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"select",
+	"multiSelect",
+	"portableText",
+	"image",
+	"file",
+	"reference",
+	"json",
+	"slug",
+]);
+
+const fieldValidation = z
+	.object({
+		required: z.boolean().optional(),
+		min: z.number().optional(),
+		max: z.number().optional(),
+		minLength: z.number().int().min(0).optional(),
+		maxLength: z.number().int().min(0).optional(),
+		pattern: z.string().optional(),
+		options: z.array(z.string()).optional(),
+	})
+	.optional();
+
+const fieldWidgetOptions = z.record(z.string(), z.unknown()).optional();
+
+export const createCollectionBody = z
+	.object({
+		slug: z.string().min(1).max(63).regex(slugPattern, "Invalid slug format"),
+		label: z.string().min(1),
+		labelSingular: z.string().optional(),
+		description: z.string().optional(),
+		icon: z.string().optional(),
+		supports: z.array(collectionSupportValues).optional(),
+		source: z.string().regex(collectionSourcePattern).optional(),
+		urlPattern: z.string().optional(),
+		hasSeo: z.boolean().optional(),
+	})
+	.meta({ id: "CreateCollectionBody" });
+
+export const updateCollectionBody = z
+	.object({
+		label: z.string().min(1).optional(),
+		labelSingular: z.string().optional(),
+		description: z.string().optional(),
+		icon: z.string().optional(),
+		supports: z.array(collectionSupportValues).optional(),
+		urlPattern: z.string().nullish(),
+		hasSeo: z.boolean().optional(),
+		commentsEnabled: z.boolean().optional(),
+		commentsModeration: z.enum(["all", "first_time", "none"]).optional(),
+		commentsClosedAfterDays: z.number().int().min(0).optional(),
+		commentsAutoApproveUsers: z.boolean().optional(),
+	})
+	.meta({ id: "UpdateCollectionBody" });
+
+export const createFieldBody = z
+	.object({
+		slug: z.string().min(1).max(63).regex(slugPattern, "Invalid slug format"),
+		label: z.string().min(1),
+		type: fieldTypeValues,
+		required: z.boolean().optional(),
+		unique: z.boolean().optional(),
+		defaultValue: z.unknown().optional(),
+		validation: fieldValidation,
+		widget: z.string().optional(),
+		options: fieldWidgetOptions,
+		sortOrder: z.number().int().min(0).optional(),
+		searchable: z.boolean().optional(),
+		translatable: z.boolean().optional(),
+	})
+	.meta({ id: "CreateFieldBody" });
+
+export const updateFieldBody = z
+	.object({
+		label: z.string().min(1).optional(),
+		required: z.boolean().optional(),
+		unique: z.boolean().optional(),
+		defaultValue: z.unknown().optional(),
+		validation: fieldValidation,
+		widget: z.string().optional(),
+		options: fieldWidgetOptions,
+		sortOrder: z.number().int().min(0).optional(),
+		searchable: z.boolean().optional(),
+		translatable: z.boolean().optional(),
+	})
+	.meta({ id: "UpdateFieldBody" });
+
+export const fieldReorderBody = z
+	.object({
+		fieldSlugs: z.array(z.string().min(1)),
+	})
+	.meta({ id: "FieldReorderBody" });
+
+export const orphanRegisterBody = z
+	.object({
+		label: z.string().optional(),
+		labelSingular: z.string().optional(),
+		description: z.string().optional(),
+	})
+	.meta({ id: "OrphanRegisterBody" });
+
+export const schemaExportQuery = z.object({
+	format: z.string().optional(),
+});
+
+export const collectionGetQuery = z.object({
+	includeFields: z
+		.string()
+		.transform((v) => v === "true")
+		.optional(),
+});
+
+// ---------------------------------------------------------------------------
+// Schema: Response schemas
+// ---------------------------------------------------------------------------
+
+export const collectionSchema = z
+	.object({
+		id: z.string(),
+		slug: z.string(),
+		label: z.string(),
+		labelSingular: z.string().nullable(),
+		description: z.string().nullable(),
+		icon: z.string().nullable(),
+		supports: z.array(z.string()),
+		source: z.string().nullable(),
+		urlPattern: z.string().nullable(),
+		hasSeo: z.boolean(),
+		createdAt: z.string(),
+		updatedAt: z.string(),
+	})
+	.meta({ id: "Collection" });
+
+export const fieldSchema = z
+	.object({
+		id: z.string(),
+		collectionId: z.string(),
+		slug: z.string(),
+		label: z.string(),
+		type: fieldTypeValues,
+		required: z.boolean(),
+		unique: z.boolean(),
+		defaultValue: z.unknown().nullable(),
+		validation: z.record(z.string(), z.unknown()).nullable(),
+		widget: z.string().nullable(),
+		options: z.record(z.string(), z.unknown()).nullable(),
+		sortOrder: z.number().int(),
+		searchable: z.boolean(),
+		translatable: z.boolean(),
+		createdAt: z.string(),
+		updatedAt: z.string(),
+	})
+	.meta({ id: "Field" });
+
+export const collectionResponseSchema = z
+	.object({ item: collectionSchema })
+	.meta({ id: "CollectionResponse" });
+
+export const collectionWithFieldsResponseSchema = z
+	.object({
+		item: collectionSchema.extend({ fields: z.array(fieldSchema) }),
+	})
+	.meta({ id: "CollectionWithFieldsResponse" });
+
+export const collectionListResponseSchema = z
+	.object({ items: z.array(collectionSchema) })
+	.meta({ id: "CollectionListResponse" });
+
+export const fieldResponseSchema = z.object({ item: fieldSchema }).meta({ id: "FieldResponse" });
+
+export const fieldListResponseSchema = z
+	.object({ items: z.array(fieldSchema) })
+	.meta({ id: "FieldListResponse" });
+
+export const orphanedTableSchema = z
+	.object({
+		slug: z.string(),
+		tableName: z.string(),
+		rowCount: z.number().int(),
+	})
+	.meta({ id: "OrphanedTable" });
+
+export const orphanedTableListResponseSchema = z
+	.object({ items: z.array(orphanedTableSchema) })
+	.meta({ id: "OrphanedTableListResponse" });

package/src/api/schemas/search.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+
+import { localeCode } from "./common.js";
+
+// ---------------------------------------------------------------------------
+// Search: Input schemas
+// ---------------------------------------------------------------------------
+
+export const searchQuery = z
+	.object({
+		q: z.string().min(1),
+		collections: z.string().optional(),
+		status: z.string().optional(),
+		locale: localeCode.optional(),
+		limit: z.coerce.number().int().min(1).max(100).optional(),
+	})
+	.meta({ id: "SearchQuery" });
+
+export const searchSuggestQuery = z
+	.object({
+		q: z.string().min(1),
+		collections: z.string().optional(),
+		locale: localeCode.optional(),
+		limit: z.coerce.number().int().min(1).max(20).optional(),
+	})
+	.meta({ id: "SearchSuggestQuery" });
+
+export const searchRebuildBody = z
+	.object({
+		collection: z.string().min(1),
+	})
+	.meta({ id: "SearchRebuildBody" });
+
+export const searchEnableBody = z
+	.object({
+		collection: z.string().min(1),
+		enabled: z.boolean(),
+		weights: z.record(z.string(), z.number()).optional(),
+	})
+	.meta({ id: "SearchEnableBody" });
+
+// ---------------------------------------------------------------------------
+// Search: Response schemas
+// ---------------------------------------------------------------------------
+
+export const searchResultSchema = z
+	.object({
+		collection: z.string(),
+		id: z.string(),
+		slug: z.string().nullable(),
+		locale: z.string(),
+		title: z.string().optional(),
+		snippet: z.string().optional(),
+		score: z.number(),
+	})
+	.meta({ id: "SearchResult" });
+
+export const searchResponseSchema = z
+	.object({
+		items: z.array(searchResultSchema),
+		nextCursor: z.string().optional(),
+	})
+	.meta({ id: "SearchResponse" });

package/src/api/schemas/sections.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Sections: Input schemas
+// ---------------------------------------------------------------------------
+
+const sectionSource = z.enum(["theme", "user", "import"]);
+
+export const sectionsListQuery = z
+	.object({
+		source: sectionSource.optional(),
+		search: z.string().optional(),
+		limit: z.coerce.number().int().min(1).max(100).optional(),
+		cursor: z.string().optional(),
+	})
+	.meta({ id: "SectionsListQuery" });
+
+export const createSectionBody = z
+	.object({
+		slug: z.string().min(1),
+		title: z.string().min(1),
+		description: z.string().optional(),
+		keywords: z.array(z.string()).optional(),
+		content: z.array(z.record(z.string(), z.unknown())),
+		previewMediaId: z.string().optional(),
+		source: sectionSource.optional(),
+		themeId: z.string().optional(),
+	})
+	.meta({ id: "CreateSectionBody" });
+
+export const updateSectionBody = z
+	.object({
+		slug: z.string().min(1).optional(),
+		title: z.string().min(1).optional(),
+		description: z.string().optional(),
+		keywords: z.array(z.string()).optional(),
+		content: z.array(z.record(z.string(), z.unknown())).optional(),
+		previewMediaId: z.string().nullish(),
+	})
+	.meta({ id: "UpdateSectionBody" });
+
+// ---------------------------------------------------------------------------
+// Sections: Response schemas
+// ---------------------------------------------------------------------------
+
+export const sectionSchema = z
+	.object({
+		id: z.string(),
+		slug: z.string(),
+		title: z.string(),
+		description: z.string().nullable(),
+		keywords: z.array(z.string()).nullable(),
+		content: z.array(z.record(z.string(), z.unknown())),
+		previewMediaId: z.string().nullable(),
+		source: z.string(),
+		themeId: z.string().nullable(),
+		createdAt: z.string(),
+		updatedAt: z.string(),
+	})
+	.meta({ id: "Section" });
+
+export const sectionListResponseSchema = z
+	.object({
+		items: z.array(sectionSchema),
+		nextCursor: z.string().optional(),
+	})
+	.meta({ id: "SectionListResponse" });

package/src/api/schemas/settings.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+
+import { httpUrl } from "./common.js";
+
+// ---------------------------------------------------------------------------
+// Settings: Input schemas
+// ---------------------------------------------------------------------------
+
+const mediaReference = z.object({
+	mediaId: z.string(),
+	alt: z.string().optional(),
+});
+
+const socialSettings = z.object({
+	twitter: z.string().optional(),
+	github: z.string().optional(),
+	facebook: z.string().optional(),
+	instagram: z.string().optional(),
+	linkedin: z.string().optional(),
+	youtube: z.string().optional(),
+});
+
+const seoSettings = z.object({
+	titleSeparator: z.string().max(10).optional(),
+	defaultOgImage: mediaReference.optional(),
+	robotsTxt: z.string().max(5000).optional(),
+	googleVerification: z.string().max(100).optional(),
+	bingVerification: z.string().max(100).optional(),
+});
+
+export const settingsUpdateBody = z
+	.object({
+		title: z.string().optional(),
+		tagline: z.string().optional(),
+		logo: mediaReference.optional(),
+		favicon: mediaReference.optional(),
+		url: z.union([httpUrl, z.literal("")]).optional(),
+		postsPerPage: z.number().int().min(1).max(100).optional(),
+		dateFormat: z.string().optional(),
+		timezone: z.string().optional(),
+		social: socialSettings.optional(),
+		seo: seoSettings.optional(),
+	})
+	.meta({ id: "SettingsUpdateBody" });
+
+// ---------------------------------------------------------------------------
+// Settings: Response schemas
+// ---------------------------------------------------------------------------
+
+export const siteSettingsSchema = z
+	.object({
+		title: z.string().optional(),
+		tagline: z.string().optional(),
+		logo: mediaReference.optional(),
+		favicon: mediaReference.optional(),
+		url: z.string().optional(),
+		postsPerPage: z.number().int().optional(),
+		dateFormat: z.string().optional(),
+		timezone: z.string().optional(),
+		social: socialSettings.optional(),
+		seo: seoSettings.optional(),
+	})
+	.meta({ id: "SiteSettings" });

package/src/api/schemas/setup.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Setup
+// ---------------------------------------------------------------------------
+
+/** Registration credential — duplicated reference for setup flow.
+ *  The canonical definition lives in auth.ts but setup needs it independently
+ *  because setup runs before auth is configured. */
+const authenticatorTransport = z.enum(["usb", "nfc", "ble", "internal", "hybrid"]);
+
+const registrationCredential = z.object({
+	id: z.string(),
+	rawId: z.string(),
+	type: z.literal("public-key"),
+	response: z.object({
+		clientDataJSON: z.string(),
+		attestationObject: z.string(),
+		transports: z.array(authenticatorTransport).optional(),
+	}),
+	authenticatorAttachment: z.enum(["platform", "cross-platform"]).optional(),
+});
+
+export const setupBody = z.object({
+	title: z.string().min(1),
+	tagline: z.string().optional(),
+	includeContent: z.boolean(),
+});
+
+export const setupAdminBody = z.object({
+	email: z.string().email(),
+	name: z.string().optional(),
+});
+
+export const setupAdminVerifyBody = z.object({
+	credential: registrationCredential,
+});

package/src/api/schemas/taxonomies.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Taxonomy definitions: Input schemas
+// ---------------------------------------------------------------------------
+
+/** Collection slug format: lowercase alphanumeric + underscores, starts with letter */
+const collectionSlugPattern = /^[a-z][a-z0-9_]*$/;
+
+export const createTaxonomyDefBody = z
+	.object({
+		name: z
+			.string()
+			.min(1)
+			.max(63)
+			.regex(/^[a-z][a-z0-9_]*$/, "Name must be lowercase alphanumeric with underscores"),
+		label: z.string().min(1).max(200),
+		hierarchical: z.boolean().optional().default(false),
+		collections: z
+			.array(
+				z.string().min(1).max(63).regex(collectionSlugPattern, "Invalid collection slug format"),
+			)
+			.max(100)
+			.optional()
+			.default([]),
+	})
+	.meta({ id: "CreateTaxonomyDefBody" });
+
+// ---------------------------------------------------------------------------
+// Taxonomy terms: Input schemas
+// ---------------------------------------------------------------------------
+
+export const createTermBody = z
+	.object({
+		slug: z.string().min(1),
+		label: z.string().min(1),
+		parentId: z.string().nullish(),
+		description: z.string().optional(),
+	})
+	.meta({ id: "CreateTermBody" });
+
+export const updateTermBody = z
+	.object({
+		slug: z.string().min(1).optional(),
+		label: z.string().min(1).optional(),
+		parentId: z.string().nullish(),
+		description: z.string().optional(),
+	})
+	.meta({ id: "UpdateTermBody" });
+
+// ---------------------------------------------------------------------------
+// Taxonomies: Response schemas
+// ---------------------------------------------------------------------------
+
+export const taxonomyDefSchema = z
+	.object({
+		id: z.string(),
+		name: z.string(),
+		label: z.string(),
+		labelSingular: z.string().optional(),
+		hierarchical: z.boolean(),
+		collections: z.array(z.string()),
+	})
+	.meta({ id: "TaxonomyDef" });
+
+export const taxonomyListResponseSchema = z
+	.object({ taxonomies: z.array(taxonomyDefSchema) })
+	.meta({ id: "TaxonomyListResponse" });
+
+export const termSchema = z
+	.object({
+		id: z.string(),
+		name: z.string(),
+		slug: z.string(),
+		label: z.string(),
+		parentId: z.string().nullable(),
+		description: z.string().optional(),
+	})
+	.meta({ id: "Term" });
+
+export const termWithCountSchema: z.ZodType = z
+	.object({
+		id: z.string(),
+		name: z.string(),
+		slug: z.string(),
+		label: z.string(),
+		parentId: z.string().nullable(),
+		description: z.string().optional(),
+		count: z.number().int(),
+		children: z.array(z.lazy(() => termWithCountSchema)),
+	})
+	.meta({ id: "TermWithCount" });
+
+export const termListResponseSchema = z
+	.object({ terms: z.array(termWithCountSchema) })
+	.meta({ id: "TermListResponse" });
+
+export const termResponseSchema = z.object({ term: termSchema }).meta({ id: "TermResponse" });
+
+export const termGetResponseSchema = z
+	.object({
+		term: termSchema.extend({
+			count: z.number().int(),
+			children: z.array(
+				z.object({
+					id: z.string(),
+					slug: z.string(),
+					label: z.string(),
+				}),
+			),
+		}),
+	})
+	.meta({ id: "TermGetResponse" });

package/src/api/schemas/users.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+
+import { roleLevel } from "./common.js";
+
+// ---------------------------------------------------------------------------
+// Admin / Users: Input schemas
+// ---------------------------------------------------------------------------
+
+export const usersListQuery = z
+	.object({
+		search: z.string().optional(),
+		role: z.string().optional(),
+		cursor: z.string().optional(),
+		limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+	})
+	.meta({ id: "UsersListQuery" });
+
+export const userUpdateBody = z
+	.object({
+		name: z.string().optional(),
+		email: z.string().email().optional(),
+		role: roleLevel.optional(),
+	})
+	.meta({ id: "UserUpdateBody" });
+
+export const allowedDomainCreateBody = z
+	.object({
+		domain: z.string().min(1),
+		defaultRole: roleLevel,
+	})
+	.meta({ id: "AllowedDomainCreateBody" });
+
+export const allowedDomainUpdateBody = z
+	.object({
+		enabled: z.boolean().optional(),
+		defaultRole: roleLevel.optional(),
+	})
+	.meta({ id: "AllowedDomainUpdateBody" });
+
+// ---------------------------------------------------------------------------
+// Admin / Users: Response schemas
+// ---------------------------------------------------------------------------
+
+export const userSchema = z
+	.object({
+		id: z.string(),
+		email: z.string(),
+		name: z.string().nullable(),
+		avatarUrl: z.string().nullable(),
+		role: z.number().int(),
+		emailVerified: z.boolean(),
+		disabled: z.boolean(),
+		createdAt: z.string(),
+		updatedAt: z.string(),
+		lastLogin: z.string().nullable(),
+		credentialCount: z.number().int().optional(),
+		oauthProviders: z.array(z.string()).optional(),
+	})
+	.meta({ id: "User" });
+
+export const userListResponseSchema = z
+	.object({
+		items: z.array(userSchema),
+		nextCursor: z.string().optional(),
+	})
+	.meta({ id: "UserListResponse" });
+
+export const userDetailSchema = z
+	.object({
+		id: z.string(),
+		email: z.string(),
+		name: z.string().nullable(),
+		avatarUrl: z.string().nullable(),
+		role: z.number().int(),
+		emailVerified: z.boolean(),
+		disabled: z.boolean(),
+		createdAt: z.string(),
+		updatedAt: z.string(),
+		lastLogin: z.string().nullable(),
+		credentials: z.array(
+			z.object({
+				id: z.string(),
+				name: z.string().nullable(),
+				deviceType: z.string().nullable(),
+				createdAt: z.string(),
+				lastUsedAt: z.string(),
+			}),
+		),
+		oauthAccounts: z.array(
+			z.object({
+				provider: z.string(),
+				createdAt: z.string(),
+			}),
+		),
+	})
+	.meta({ id: "UserDetail" });