@beignet/core 0.0.7 → 0.0.9

package/src/providers/metadata.ts

@@ -19,6 +19,14 @@ export type ProviderPackageRegistrationMetadata = {
   tokens?: readonly string[];
 };
 
+export type ProviderPackageVariantMetadata = {
+  name: string;
+  displayName?: string;
+  env?: readonly string[];
+  requiredEnv?: readonly string[];
+  registration?: ProviderPackageRegistrationMetadata;
+};
+
 export type ProviderPackageMetadata = {
   displayName?: string;
   ports?: readonly string[];
@@ -26,6 +34,7 @@ export type ProviderPackageMetadata = {
   env?: readonly string[];
   requiredEnv?: readonly string[];
   registration?: ProviderPackageRegistrationMetadata;
+  variants?: readonly ProviderPackageVariantMetadata[];
   watchers?: readonly string[];
 };
 
@@ -101,9 +110,33 @@ export function parseProviderPackageMetadata(
   const appPorts = parseAppPorts(input.appPorts, issues);
   if (appPorts !== undefined) metadata.appPorts = appPorts;
 
-  const registration = parseRegistration(input.registration, issues);
+  const registration = parseRegistration(
+    input.registration,
+    issues,
+    "beignet.provider.registration",
+  );
   if (registration !== undefined) metadata.registration = registration;
 
+  const variants = parseVariants(input.variants, issues);
+  if (variants !== undefined) metadata.variants = variants;
+
+  if (input.variants !== undefined) {
+    if (input.requiredEnv !== undefined) {
+      issues.push({
+        path: "beignet.provider.requiredEnv",
+        message:
+          "must not be set when beignet.provider.variants is present; declare requiredEnv on each variant instead",
+      });
+    }
+    if (input.registration !== undefined) {
+      issues.push({
+        path: "beignet.provider.registration",
+        message:
+          "must not be set when beignet.provider.variants is present; declare registration on each variant instead",
+      });
+    }
+  }
+
   if (issues.length > 0) {
     return { success: false, issues };
   }
@@ -169,12 +202,103 @@ function parseAppPorts(
   return parsed;
 }
 
+function parseVariants(
+  value: unknown,
+  issues: ProviderPackageMetadataIssue[],
+): ProviderPackageVariantMetadata[] | undefined {
+  if (value === undefined) return undefined;
+  const path = "beignet.provider.variants";
+  if (!Array.isArray(value)) {
+    issues.push({ path, message: "must be an array of variant objects" });
+    return undefined;
+  }
+  if (value.length === 0) {
+    issues.push({
+      path,
+      message: "must include at least one variant when present",
+    });
+    return undefined;
+  }
+
+  const parsed: ProviderPackageVariantMetadata[] = [];
+  const seenNames = new Set<string>();
+  for (const [index, entry] of value.entries()) {
+    const entryPath = `${path}[${index}]`;
+    if (!isRecord(entry)) {
+      issues.push({ path: entryPath, message: "must be an object" });
+      continue;
+    }
+
+    let name: string | undefined;
+    if (typeof entry.name !== "string" || entry.name.length === 0) {
+      issues.push({
+        path: `${entryPath}.name`,
+        message: "must be a non-empty string",
+      });
+    } else if (seenNames.has(entry.name)) {
+      issues.push({
+        path: `${entryPath}.name`,
+        message: `duplicates variant name "${entry.name}"`,
+      });
+    } else {
+      seenNames.add(entry.name);
+      name = entry.name;
+    }
+
+    let displayName: string | undefined;
+    if (entry.displayName !== undefined) {
+      if (typeof entry.displayName !== "string") {
+        issues.push({
+          path: `${entryPath}.displayName`,
+          message: "must be a string",
+        });
+      } else {
+        displayName = entry.displayName;
+      }
+    }
+
+    const env = parseStringArray(entry.env, `${entryPath}.env`, issues);
+    const requiredEnv = parseStringArray(
+      entry.requiredEnv,
+      `${entryPath}.requiredEnv`,
+      issues,
+    );
+    if (requiredEnv !== undefined) {
+      const envSet = new Set(env ?? []);
+      for (const envVar of requiredEnv) {
+        if (!envSet.has(envVar)) {
+          issues.push({
+            path: `${entryPath}.requiredEnv`,
+            message: `${envVar} must also be listed in ${entryPath}.env`,
+          });
+        }
+      }
+    }
+
+    const registration = parseRegistration(
+      entry.registration,
+      issues,
+      `${entryPath}.registration`,
+    );
+
+    if (name === undefined) continue;
+    const variant: ProviderPackageVariantMetadata = { name };
+    if (displayName !== undefined) variant.displayName = displayName;
+    if (env !== undefined) variant.env = env;
+    if (requiredEnv !== undefined) variant.requiredEnv = requiredEnv;
+    if (registration !== undefined) variant.registration = registration;
+    parsed.push(variant);
+  }
+
+  return parsed;
+}
+
 function parseRegistration(
   value: unknown,
   issues: ProviderPackageMetadataIssue[],
+  path: string,
 ): ProviderPackageRegistrationMetadata | undefined {
   if (value === undefined) return undefined;
-  const path = "beignet.provider.registration";
   if (!isRecord(value)) {
     issues.push({ path, message: "must be an object" });
     return undefined;

package/src/uploads/index.ts

@@ -541,9 +541,15 @@ export function createMemoryUploadSigner(
 export function createUploadRouter<Ctx>(
   options: CreateUploadRouterOptions<Ctx>,
 ): UploadRouter {
-  const uploads = new Map(
-    options.uploads.map((upload) => [upload.name, upload]),
-  );
+  const uploads = new Map<string, UploadDef<string, StandardSchema, Ctx>>();
+  for (const upload of options.uploads) {
+    if (uploads.has(upload.name)) {
+      throw new Error(
+        `createUploadRouter received duplicate upload name "${upload.name}". Each defineUpload(...) name must be unique.`,
+      );
+    }
+    uploads.set(upload.name, upload);
+  }
   const id = options.id ?? randomUploadId;
   const instrumentation = createProviderInstrumentation(
     options.instrumentation,
@@ -562,10 +568,13 @@ export function createUploadRouter<Ctx>(
   function findUpload(name: string) {
     const upload = uploads.get(name);
     if (!upload) {
+      const registered = [...uploads.keys()]
+        .map((registeredName) => `"${registeredName}"`)
+        .join(", ");
       throw new UploadError({
         code: "UPLOAD_NOT_FOUND",
         status: 404,
-        message: `Upload "${name}" is not registered.`,
+        message: `Upload "${name}" is not registered. Registered uploads: ${registered || "none"}. Upload routes resolve the defineUpload(...) name, not the defineUploads({...}) registry key.`,
       });
     }
     return upload;
@@ -581,12 +590,13 @@ export function createUploadRouter<Ctx>(
 
     try {
       const upload = findUpload(uploadName);
+      const parsed = parsePrepareInput(uploadName, input);
       const ctx = await resolveCtx();
-      const metadata = await parseMetadata(upload, input.metadata);
-      assertFiles(upload, input.files);
+      const metadata = await parseMetadata(upload, parsed.metadata);
+      assertFiles(upload, parsed.files);
 
       const files: PreparedUploadResultFile[] = [];
-      for (const file of input.files) {
+      for (const file of parsed.files) {
         const uploadId = id();
         await assertAuthorized(upload, { ctx, metadata, file, uploadId });
         const key = await upload.key({ ctx, metadata, file, uploadId });
@@ -652,12 +662,13 @@ export function createUploadRouter<Ctx>(
 
     try {
       const upload = findUpload(uploadName);
+      const parsed = parseCompleteInput(uploadName, input);
       const ctx = await resolveCtx();
-      const metadata = await parseMetadata(upload, input.metadata);
-      assertFiles(upload, input.files);
+      const metadata = await parseMetadata(upload, parsed.metadata);
+      assertFiles(upload, parsed.files);
 
       const files: CompletedUploadFile[] = [];
-      for (const file of input.files) {
+      for (const file of parsed.files) {
         await assertAuthorized(upload, {
           ctx,
           metadata,
@@ -827,13 +838,29 @@ export function createUploadRouter<Ctx>(
     async handleRequest(request, requestOptions) {
       try {
         if (requestOptions.action === "prepare") {
-          const input = (await request.json()) as PrepareUploadInput;
-          return jsonResponse(await prepare(requestOptions.uploadName, input));
+          const input = await readJsonBody(request, {
+            uploadName: requestOptions.uploadName,
+            action: "prepare",
+          });
+          return jsonResponse(
+            await prepare(
+              requestOptions.uploadName,
+              input as PrepareUploadInput,
+            ),
+          );
         }
 
         if (requestOptions.action === "complete") {
-          const input = (await request.json()) as CompleteUploadInput;
-          return jsonResponse(await complete(requestOptions.uploadName, input));
+          const input = await readJsonBody(request, {
+            uploadName: requestOptions.uploadName,
+            action: "complete",
+          });
+          return jsonResponse(
+            await complete(
+              requestOptions.uploadName,
+              input as CompleteUploadInput,
+            ),
+          );
         }
 
         const formData = await request.formData();
@@ -849,6 +876,104 @@ export function createUploadRouter<Ctx>(
   };
 }
 
+async function readJsonBody(
+  request: Request,
+  context: { uploadName: string; action: "prepare" | "complete" },
+): Promise<unknown> {
+  try {
+    return await request.json();
+  } catch {
+    throw new UploadError({
+      code: "INVALID_UPLOAD_BODY",
+      status: 400,
+      message: `Upload "${context.uploadName}" ${context.action} body must be valid JSON.`,
+    });
+  }
+}
+
+interface UploadBodyIssue {
+  message: string;
+  path: (string | number)[];
+}
+
+function collectBodyIssues(
+  body: unknown,
+  options: { requireCompletedFileFields: boolean },
+): UploadBodyIssue[] {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    return [{ message: "Body must be a JSON object.", path: [] }];
+  }
+
+  const files = (body as { files?: unknown }).files;
+  if (!Array.isArray(files)) {
+    return [{ message: 'Body must include a "files" array.', path: ["files"] }];
+  }
+
+  const issues: UploadBodyIssue[] = [];
+  for (const [index, file] of files.entries()) {
+    if (typeof file !== "object" || file === null || Array.isArray(file)) {
+      issues.push({
+        message: "Each file must be an object.",
+        path: ["files", index],
+      });
+      continue;
+    }
+
+    if (!options.requireCompletedFileFields) continue;
+
+    const completed = file as { uploadId?: unknown; key?: unknown };
+    if (typeof completed.uploadId !== "string") {
+      issues.push({
+        message: 'Each completed file must include a string "uploadId".',
+        path: ["files", index, "uploadId"],
+      });
+    }
+    if (typeof completed.key !== "string") {
+      issues.push({
+        message: 'Each completed file must include a string "key".',
+        path: ["files", index, "key"],
+      });
+    }
+  }
+  return issues;
+}
+
+function parsePrepareInput(
+  uploadName: string,
+  body: unknown,
+): PrepareUploadInput {
+  const issues = collectBodyIssues(body, {
+    requireCompletedFileFields: false,
+  });
+  if (issues.length > 0) {
+    throw new UploadError({
+      code: "INVALID_UPLOAD_BODY",
+      status: 400,
+      message: `Upload "${uploadName}" prepare body is invalid.`,
+      details: { issues },
+    });
+  }
+  return body as PrepareUploadInput;
+}
+
+function parseCompleteInput(
+  uploadName: string,
+  body: unknown,
+): CompleteUploadInput {
+  const issues = collectBodyIssues(body, {
+    requireCompletedFileFields: true,
+  });
+  if (issues.length > 0) {
+    throw new UploadError({
+      code: "INVALID_UPLOAD_BODY",
+      status: 400,
+      message: `Upload "${uploadName}" complete body is invalid.`,
+      details: { issues },
+    });
+  }
+  return body as CompleteUploadInput;
+}
+
 async function parseMetadata<U extends UploadDef>(
   upload: U,
   input: unknown,