@structcms/api 0.1.0 → 0.1.1

package/README.md

@@ -2,7 +2,7 @@
 
 Storage, domain API, delivery API, and content export for StructCMS. Provides Supabase-agnostic adapter interfaces, handler functions for content CRUD, media management, and JSON export.
 
-For architectural context, see [ARCHITECTURE.md](../../ARCHITECTURE.md) (Layer 3: Storage, Layer 4: Domain API, Layer 5: Delivery API).
+For architectural context, see [ARCHITECTURE.md](../../docs/ARCHITECTURE.md) (Layer 3: Storage, Layer 4: Domain API, Layer 5: Delivery API).
 
 **[← Back to main README](../../README.md)**
 
@@ -164,7 +164,7 @@ Rich text content is sanitized on write using `sanitize-html` to prevent XSS att
 
 ## Database
 
-Migrations live in `supabase/migrations/` at the monorepo root. See [ARCHITECTURE.md](../../ARCHITECTURE.md) for the database schema.
+Migrations live in `supabase/migrations/` at the monorepo root. See [ARCHITECTURE.md](../../docs/ARCHITECTURE.md) for the database schema.
 
 ## Development
 

package/dist/index.cjs

@@ -30,22 +30,34 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ALLOWED_DOCUMENT_MIME_TYPES: () => ALLOWED_DOCUMENT_MIME_TYPES,
   ALLOWED_MIME_TYPES: () => ALLOWED_MIME_TYPES,
+  ALL_ALLOWED_MIME_TYPES: () => ALL_ALLOWED_MIME_TYPES,
   AuthError: () => AuthError,
   AuthValidationError: () => AuthValidationError,
+  CreateNavigationSchema: () => CreateNavigationSchema,
+  CreatePageSchema: () => CreatePageSchema,
+  MAX_FILE_SIZE: () => MAX_FILE_SIZE2,
   MediaError: () => MediaError,
+  MediaUploadSchema: () => MediaUploadSchema,
   MediaValidationError: () => MediaValidationError,
+  SignInSchema: () => SignInSchema,
   StorageError: () => StorageError,
   StorageValidationError: () => StorageValidationError,
   SupabaseAuthAdapter: () => SupabaseAuthAdapter,
   SupabaseMediaAdapter: () => SupabaseMediaAdapter,
   SupabaseStorageAdapter: () => SupabaseStorageAdapter,
+  UpdateNavigationSchema: () => UpdateNavigationSchema,
+  UpdatePageSchema: () => UpdatePageSchema,
+  createAuditLogger: () => createAuditLogger,
   createAuthAdapter: () => createAuthAdapter,
   createAuthMiddleware: () => createAuthMiddleware,
   createMediaAdapter: () => createMediaAdapter,
+  createRateLimiter: () => createRateLimiter,
   createStorageAdapter: () => createStorageAdapter,
   createSupabaseAdapters: () => createSupabaseAdapters,
   ensureUniqueSlug: () => ensureUniqueSlug,
+  generateCsrfToken: () => generateCsrfToken,
   generateSlug: () => generateSlug,
   handleCreateNavigation: () => handleCreateNavigation,
   handleCreatePage: () => handleCreatePage,
@@ -70,7 +82,10 @@ __export(index_exports, {
   handleUpdatePage: () => handleUpdatePage,
   handleUploadMedia: () => handleUploadMedia,
   handleVerifySession: () => handleVerifySession,
-  resolveMediaReferences: () => resolveMediaReferences
+  resolveMediaReferences: () => resolveMediaReferences,
+  stripTags: () => stripTags,
+  validateCsrfToken: () => validateCsrfToken,
+  withAuditLog: () => withAuditLog
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -291,6 +306,12 @@ var SANITIZE_OPTIONS = {
 function sanitizeString(value) {
   return (0, import_sanitize_html.default)(value, SANITIZE_OPTIONS);
 }
+function stripTags(value) {
+  return (0, import_sanitize_html.default)(value, {
+    allowedTags: [],
+    allowedAttributes: {}
+  });
+}
 function sanitizeValue(value) {
   if (typeof value === "string") {
     return sanitizeString(value);
@@ -357,10 +378,11 @@ var StorageValidationError = class extends Error {
   }
 };
 async function handleCreatePage(adapter, input) {
-  if (!input.title.trim()) {
+  const sanitizedTitle = stripTags(input.title).trim();
+  if (!sanitizedTitle) {
     throw new StorageValidationError("Page title must not be empty", "EMPTY_TITLE");
   }
-  const slug = input.slug?.trim() || generateSlug(input.title);
+  const slug = input.slug?.trim() || generateSlug(sanitizedTitle);
   if (!slug) {
     throw new StorageValidationError(
       "Could not generate a valid slug from the provided title",
@@ -373,6 +395,7 @@ async function handleCreatePage(adapter, input) {
   const sanitizedSections = input.sections ? sanitizeSectionData(input.sections) : void 0;
   return adapter.createPage({
     ...input,
+    title: sanitizedTitle,
     slug: uniqueSlug,
     sections: sanitizedSections
   });
@@ -381,8 +404,12 @@ async function handleUpdatePage(adapter, input) {
   if (!input.id.trim()) {
     throw new StorageValidationError("Page ID must not be empty", "EMPTY_ID");
   }
-  if (input.title !== void 0 && !input.title.trim()) {
-    throw new StorageValidationError("Page title must not be empty", "EMPTY_TITLE");
+  let sanitizedTitle;
+  if (input.title !== void 0) {
+    sanitizedTitle = stripTags(input.title).trim();
+    if (!sanitizedTitle) {
+      throw new StorageValidationError("Page title must not be empty", "EMPTY_TITLE");
+    }
   }
   if (input.slug !== void 0) {
     const slug = input.slug.trim();
@@ -395,7 +422,11 @@ async function handleUpdatePage(adapter, input) {
       throw new StorageValidationError(`Slug "${slug}" is already in use`, "DUPLICATE_SLUG");
     }
   }
-  const sanitizedInput = input.sections ? { ...input, sections: sanitizeSectionData(input.sections) } : input;
+  const sanitizedInput = {
+    ...input,
+    ...sanitizedTitle !== void 0 && { title: sanitizedTitle },
+    ...input.sections && { sections: sanitizeSectionData(input.sections) }
+  };
   return adapter.updatePage(sanitizedInput);
 }
 async function handleDeletePage(adapter, id) {
@@ -405,38 +436,46 @@ async function handleDeletePage(adapter, id) {
   return adapter.deletePage(id);
 }
 async function handleCreateNavigation(adapter, input) {
-  if (!input.name.trim()) {
+  const sanitizedName = stripTags(input.name).trim();
+  if (!sanitizedName) {
     throw new StorageValidationError("Navigation name must not be empty", "EMPTY_NAME");
   }
   const existingNavigations = await adapter.listNavigations();
   const existingNames = existingNavigations.map((n) => n.name);
-  if (existingNames.includes(input.name.trim())) {
+  if (existingNames.includes(sanitizedName)) {
     throw new StorageValidationError(
-      `Navigation name "${input.name.trim()}" is already in use`,
+      `Navigation name "${sanitizedName}" is already in use`,
       "DUPLICATE_NAME"
     );
   }
-  return adapter.createNavigation(input);
+  return adapter.createNavigation({
+    ...input,
+    name: sanitizedName
+  });
 }
 async function handleUpdateNavigation(adapter, input) {
   if (!input.id.trim()) {
     throw new StorageValidationError("Navigation ID must not be empty", "EMPTY_ID");
   }
+  let sanitizedName;
   if (input.name !== void 0) {
-    const name = input.name.trim();
-    if (!name) {
+    sanitizedName = stripTags(input.name).trim();
+    if (!sanitizedName) {
       throw new StorageValidationError("Navigation name must not be empty", "EMPTY_NAME");
     }
     const existingNavigations = await adapter.listNavigations();
     const existingNames = existingNavigations.filter((n) => n.id !== input.id).map((n) => n.name);
-    if (existingNames.includes(name)) {
+    if (existingNames.includes(sanitizedName)) {
       throw new StorageValidationError(
-        `Navigation name "${name}" is already in use`,
+        `Navigation name "${sanitizedName}" is already in use`,
         "DUPLICATE_NAME"
       );
     }
   }
-  return adapter.updateNavigation(input);
+  return adapter.updateNavigation({
+    ...input,
+    ...sanitizedName !== void 0 && { name: sanitizedName }
+  });
 }
 async function handleDeleteNavigation(adapter, id) {
   if (!id.trim()) {
@@ -445,12 +484,61 @@ async function handleDeleteNavigation(adapter, id) {
   return adapter.deleteNavigation(id);
 }
 
+// src/validation/schemas.ts
+var import_zod = require("zod");
+var MAX_FILE_SIZE = 50 * 1024 * 1024;
+var PageSectionSchema = import_zod.z.object({
+  id: import_zod.z.string().optional(),
+  type: import_zod.z.string(),
+  data: import_zod.z.record(import_zod.z.unknown())
+});
+var CreatePageSchema = import_zod.z.object({
+  title: import_zod.z.string().max(200, "Title must not exceed 200 characters"),
+  pageType: import_zod.z.string(),
+  slug: import_zod.z.string().max(200, "Slug must not exceed 200 characters").optional(),
+  sections: import_zod.z.array(PageSectionSchema).optional()
+});
+var UpdatePageSchema = CreatePageSchema.partial();
+var NavigationItemSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    label: import_zod.z.string(),
+    href: import_zod.z.string(),
+    children: import_zod.z.array(NavigationItemSchema).optional()
+  })
+);
+var CreateNavigationSchema = import_zod.z.object({
+  name: import_zod.z.string().max(100, "Name must not exceed 100 characters"),
+  items: import_zod.z.array(NavigationItemSchema)
+});
+var UpdateNavigationSchema = CreateNavigationSchema.partial();
+var SignInSchema = import_zod.z.object({
+  email: import_zod.z.string().email("Invalid email address"),
+  password: import_zod.z.string().min(1, "Password is required")
+});
+var MediaUploadSchema = import_zod.z.object({
+  filename: import_zod.z.string().max(255, "Filename must not exceed 255 characters"),
+  mimeType: import_zod.z.string(),
+  size: import_zod.z.number().max(MAX_FILE_SIZE, `File size must not exceed ${MAX_FILE_SIZE / 1024 / 1024}MB`),
+  data: import_zod.z.instanceof(ArrayBuffer)
+});
+
 // src/media/resolve.ts
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var MEDIA_FIELD_SUFFIXES = ["_image", "_media", "_photo", "_thumbnail", "_avatar", "_icon"];
+var MEDIA_FIELD_SUFFIXES = [
+  "_image",
+  "_media",
+  "_photo",
+  "_thumbnail",
+  "_avatar",
+  "_icon",
+  "_file",
+  "_document",
+  "_attachment",
+  "_download"
+];
 function isMediaField(fieldName) {
   const lower = fieldName.toLowerCase();
-  if (lower === "image" || lower === "media" || lower === "photo" || lower === "thumbnail" || lower === "avatar" || lower === "icon") {
+  if (lower === "image" || lower === "media" || lower === "photo" || lower === "thumbnail" || lower === "avatar" || lower === "icon" || lower === "file" || lower === "document" || lower === "attachment" || lower === "download") {
     return true;
   }
   return MEDIA_FIELD_SUFFIXES.some((suffix) => lower.endsWith(suffix));
@@ -538,6 +626,7 @@ async function handleGetNavigation(adapter, name) {
 }
 
 // src/media/types.ts
+var MAX_FILE_SIZE2 = 50 * 1024 * 1024;
 var ALLOWED_MIME_TYPES = [
   "image/jpeg",
   "image/png",
@@ -545,8 +634,29 @@ var ALLOWED_MIME_TYPES = [
   "image/webp",
   "image/svg+xml"
 ];
+var ALLOWED_DOCUMENT_MIME_TYPES = [
+  "application/pdf",
+  "application/msword",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.ms-excel",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.ms-powerpoint",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  "text/plain",
+  "text/csv",
+  "application/zip",
+  "application/gzip"
+];
+var ALL_ALLOWED_MIME_TYPES = [
+  ...ALLOWED_MIME_TYPES,
+  ...ALLOWED_DOCUMENT_MIME_TYPES
+];
 
 // src/media/supabase-adapter.ts
+function deriveCategory(mimeType) {
+  const imageMimes = ALLOWED_MIME_TYPES;
+  return imageMimes.includes(mimeType) ? "image" : "document";
+}
 var MediaError = class extends Error {
   constructor(message, code, details) {
     super(message);
@@ -588,6 +698,7 @@ var SupabaseMediaAdapter = class {
       url: this.getPublicUrl(row.storage_path),
       mimeType: row.mime_type,
       size: row.size,
+      category: row.category,
       createdAt: new Date(row.created_at)
     };
   }
@@ -608,7 +719,8 @@ var SupabaseMediaAdapter = class {
       filename: input.filename,
       storage_path: storagePath,
       mime_type: input.mimeType,
-      size: input.size
+      size: input.size,
+      category: deriveCategory(input.mimeType)
     }).select().single();
     if (dbError) {
       await this.client.storage.from(this.bucketName).remove([storagePath]);
@@ -635,6 +747,9 @@ var SupabaseMediaAdapter = class {
     if (filter?.mimeType) {
       query = query.eq("mime_type", filter.mimeType);
     }
+    if (filter?.category) {
+      query = query.eq("category", filter.category);
+    }
     query = query.order("created_at", { ascending: false });
     if (filter?.limit) {
       query = query.limit(filter.limit);
@@ -684,16 +799,25 @@ var MediaValidationError = class extends Error {
   }
 };
 function validateMimeType(mimeType) {
-  const allowed = ALLOWED_MIME_TYPES;
+  const allowed = ALL_ALLOWED_MIME_TYPES;
   if (!allowed.includes(mimeType)) {
     throw new MediaValidationError(
-      `Invalid file type: ${mimeType}. Allowed types: ${ALLOWED_MIME_TYPES.join(", ")}`,
+      `Invalid file type: ${mimeType}. Allowed types: ${ALL_ALLOWED_MIME_TYPES.join(", ")}`,
       "INVALID_MIME_TYPE"
     );
   }
 }
+function validateFileSize(size) {
+  if (size > MAX_FILE_SIZE2) {
+    throw new MediaValidationError(
+      `File size exceeds maximum allowed size of ${MAX_FILE_SIZE2 / 1024 / 1024}MB`,
+      "FILE_TOO_LARGE"
+    );
+  }
+}
 async function handleUploadMedia(adapter, input) {
   validateMimeType(input.mimeType);
+  validateFileSize(input.size);
   return adapter.upload(input);
 }
 async function handleGetMedia(adapter, id) {
@@ -947,6 +1071,82 @@ function createAuthMiddleware(config) {
   };
 }
 
+// src/auth/csrf.ts
+function generateCsrfToken() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function validateCsrfToken(cookieToken, headerToken) {
+  if (!cookieToken || !headerToken) {
+    return false;
+  }
+  if (cookieToken.trim() === "" || headerToken.trim() === "") {
+    return false;
+  }
+  return cookieToken === headerToken;
+}
+
+// src/auth/rate-limiter.ts
+function createRateLimiter(config) {
+  const { windowMs, maxRequests } = config;
+  const entries = /* @__PURE__ */ new Map();
+  function cleanupEntry(entry, now) {
+    const windowStart = now - windowMs;
+    entry.timestamps = entry.timestamps.filter((ts) => ts > windowStart);
+  }
+  function scheduleCleanup(key) {
+    const entry = entries.get(key);
+    if (!entry) return;
+    if (entry.timeoutId) {
+      clearTimeout(entry.timeoutId);
+    }
+    entry.timeoutId = setTimeout(() => {
+      const currentEntry = entries.get(key);
+      if (currentEntry) {
+        cleanupEntry(currentEntry, Date.now());
+        if (currentEntry.timestamps.length === 0) {
+          entries.delete(key);
+        } else {
+          scheduleCleanup(key);
+        }
+      }
+    }, windowMs);
+  }
+  return {
+    check(key) {
+      const now = Date.now();
+      let entry = entries.get(key);
+      if (!entry) {
+        entry = { timestamps: [] };
+        entries.set(key, entry);
+      }
+      cleanupEntry(entry, now);
+      if (entry.timestamps.length >= maxRequests) {
+        const oldestTimestamp = entry.timestamps[0] ?? now;
+        const retryAfterMs = oldestTimestamp + windowMs - now;
+        const retryAfterSeconds = Math.ceil(retryAfterMs / 1e3);
+        return {
+          allowed: false,
+          retryAfter: retryAfterSeconds
+        };
+      }
+      entry.timestamps.push(now);
+      scheduleCleanup(key);
+      return {
+        allowed: true
+      };
+    },
+    reset(key) {
+      const entry = entries.get(key);
+      if (entry?.timeoutId) {
+        clearTimeout(entry.timeoutId);
+      }
+      entries.delete(key);
+    }
+  };
+}
+
 // src/supabase/factory.ts
 function readEnv(name) {
   const processLike = globalThis.process;
@@ -1077,24 +1277,66 @@ async function handleExportSite(storageAdapter, mediaAdapter) {
     contentDisposition: contentDisposition("site-export.json")
   };
 }
+
+// src/audit/logger.ts
+var defaultSink = (entry) => {
+  const output = JSON.stringify(entry, null, 2);
+  globalThis.console?.log?.(output);
+};
+function createAuditLogger(sink = defaultSink) {
+  return {
+    log: async (entry) => {
+      await sink({
+        ...entry,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+  };
+}
+function withAuditLog(handler, options, sink) {
+  const logger = createAuditLogger(sink);
+  return (async (...args) => {
+    const result = await handler(...args);
+    await logger.log({
+      action: options.action,
+      entity: options.entity,
+      entityId: options.extractEntityId(args),
+      userId: options.extractUserId?.(args),
+      metadata: options.metadata?.(args)
+    });
+    return result;
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ALLOWED_DOCUMENT_MIME_TYPES,
   ALLOWED_MIME_TYPES,
+  ALL_ALLOWED_MIME_TYPES,
   AuthError,
   AuthValidationError,
+  CreateNavigationSchema,
+  CreatePageSchema,
+  MAX_FILE_SIZE,
   MediaError,
+  MediaUploadSchema,
   MediaValidationError,
+  SignInSchema,
   StorageError,
   StorageValidationError,
   SupabaseAuthAdapter,
   SupabaseMediaAdapter,
   SupabaseStorageAdapter,
+  UpdateNavigationSchema,
+  UpdatePageSchema,
+  createAuditLogger,
   createAuthAdapter,
   createAuthMiddleware,
   createMediaAdapter,
+  createRateLimiter,
   createStorageAdapter,
   createSupabaseAdapters,
   ensureUniqueSlug,
+  generateCsrfToken,
   generateSlug,
   handleCreateNavigation,
   handleCreatePage,
@@ -1119,6 +1361,9 @@ async function handleExportSite(storageAdapter, mediaAdapter) {
   handleUpdatePage,
   handleUploadMedia,
   handleVerifySession,
-  resolveMediaReferences
+  resolveMediaReferences,
+  stripTags,
+  validateCsrfToken,
+  withAuditLog
 });
 //# sourceMappingURL=index.cjs.map