@marktiderman/genesis-forms 0.6.0 → 0.8.0

package/dist/server.cjs

@@ -723,6 +723,7 @@ var structuredFieldTypes = [
 
 // src/photo.ts
 var PHOTO_TYPE = "photo";
+var UPLOAD_FIELD_TYPES = [PHOTO_TYPE];
 var PHOTO_FORMATS = {
   jpeg: ["image/jpeg"],
   png: ["image/png"],
@@ -2691,6 +2692,225 @@ async function allow(store, check, options = {}) {
   return true;
 }
 
+// src/uploads.ts
+function uploadFields(definition) {
+  return definition.blocks.filter(
+    (b) => b.kind === "field" && UPLOAD_FIELD_TYPES.includes(b.type)
+  );
+}
+function uploadRules(field) {
+  if (field.type !== PHOTO_TYPE) return null;
+  const limits = photoLimits(field);
+  return {
+    maxFiles: limits.maxFiles,
+    maxBytes: limits.maxBytes,
+    mimeTypes: limits.mimeTypes,
+    typeMessage: photoTypeMessage(field),
+    sizeMessage: photoSizeMessage(field),
+    countMessage: photoCountMessage(field)
+  };
+}
+var NOT_UPLOADED_MESSAGE = "A photo didn't finish uploading. Remove it and add it again.";
+function owns(upload, owner) {
+  if ("attemptHash" in owner) return upload.responseId === null && upload.attemptHash === owner.attemptHash;
+  return upload.responseId === owner.responseId || upload.responseId === null && upload.editOf === owner.responseId;
+}
+async function checkUploads(definition, answers, options) {
+  const asked = uploadFields(definition).filter((f) => photoRefs(answers[f.id]).length > 0);
+  if (!asked.length) return { ok: true, answers };
+  const { store, formId, owner } = options;
+  if (!store) throw new Error("Answers that name uploaded files need an upload store.");
+  const ids = asked.flatMap((f) => photoRefs(answers[f.id]).map((r) => r.id));
+  const stored = new Map((await store.uploadRefs(formId, ids)).map((u) => [u.id, u]));
+  const out = { ...answers };
+  const errors = {};
+  for (const field of asked) {
+    const rules = uploadRules(field);
+    const refs = photoRefs(answers[field.id]);
+    if (refs.length > rules.maxFiles) {
+      errors[field.id] = rules.countMessage;
+      continue;
+    }
+    const checked = [];
+    for (const ref of refs) {
+      const upload = stored.get(ref.id);
+      if (!upload || upload.fieldId !== field.id || !owns(upload, owner) || !upload.stored) {
+        errors[field.id] = NOT_UPLOADED_MESSAGE;
+        break;
+      }
+      const type = (upload.storedType ?? "").toLowerCase();
+      const size = upload.storedSize ?? 0;
+      if (!rules.mimeTypes.includes(type)) {
+        errors[field.id] = rules.typeMessage;
+        break;
+      }
+      if (size < 1 || size > rules.maxBytes) {
+        errors[field.id] = rules.sizeMessage;
+        break;
+      }
+      checked.push({ id: upload.id, name: upload.name, type, size });
+    }
+    out[field.id] = checked;
+  }
+  return Object.keys(errors).length ? { ok: false, errors } : { ok: true, answers: out };
+}
+async function attemptHash(attemptId) {
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(attemptId)));
+  let hex = "";
+  for (const b of digest) hex += b.toString(16).padStart(2, "0");
+  return hex;
+}
+
+// src/upload-protocol.ts
+var MAX_UPLOAD_REQUEST_BYTES = 4e3;
+
+// src/upload-handler.ts
+var UPLOAD_MESSAGES = {
+  notJson: "Send the request as JSON.",
+  tooLong: "That request is too long.",
+  reload: "Reload the page and try again.",
+  unavailable: "This form isn't available.",
+  notOpen: "This form isn't open right now.",
+  notTakingChanges: "This form isn't taking changes now.",
+  badEditLink: "This edit link doesn't work any more. Use the newest one: from your latest confirmation email, or the one shown after your last change.",
+  notUploadField: "This question doesn't take photos.",
+  rateLimited: "Too many photos from here. Try again in a few minutes.",
+  tooMany: "That's as many photos as one response can take.",
+  failed: "That photo couldn't be added. Please try again."
+};
+var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var json = (body, status = 200) => Response.json(body, { status, headers: { "cache-control": "no-store" } });
+async function readCapped(request, max) {
+  if (!request.body) return "";
+  const reader = request.body.getReader();
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > max) {
+      await reader.cancel().catch(() => {
+      });
+      return null;
+    }
+    chunks.push(value);
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+function createUploadHandler(options) {
+  const say = { ...UPLOAD_MESSAGES, ...options.messages };
+  const log = options.log ?? ((m) => console.error(`[upload] ${m}`));
+  const hash = options.hashAttempt ?? attemptHash;
+  const maxBytes = options.maxRequestBytes ?? MAX_UPLOAD_REQUEST_BYTES;
+  return async (request, params) => {
+    const contentType = (request.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
+    if (contentType !== "application/json") return json({ error: say.notJson }, 415);
+    const text = await readCapped(request, maxBytes);
+    if (text === null) return json({ error: say.tooLong }, 413);
+    let body;
+    try {
+      const parsed = JSON.parse(text);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("not an object");
+      body = parsed;
+    } catch {
+      return json({ error: say.notJson }, 400);
+    }
+    const fieldId = typeof body["fieldId"] === "string" ? body["fieldId"] : "";
+    const name = typeof body["name"] === "string" ? body["name"].trim().slice(0, 255) : "";
+    const type = typeof body["type"] === "string" ? body["type"].trim().toLowerCase() : "";
+    const size = body["size"];
+    const editing = body["edit"] !== void 0;
+    const attemptId = body["attemptId"];
+    if (!editing && (typeof attemptId !== "string" || !UUID2.test(attemptId))) {
+      return json({ error: say.reload }, 400);
+    }
+    let form;
+    try {
+      form = await options.resolveForm(request, params);
+    } catch (error) {
+      log(error instanceof Error ? error.message : "Loading the form failed.");
+      return json({ error: say.failed }, 503);
+    }
+    if (!form) return json({ error: say.unavailable }, 404);
+    if (!form.open) {
+      return editing ? json({ error: say.notTakingChanges, code: "closed" }, 409) : json({ error: say.notOpen }, 409);
+    }
+    const block = form.definition.blocks.find((b) => b.kind === "field" && b.id === fieldId);
+    const field = block?.kind === "field" ? block : null;
+    const rules = field ? uploadRules(field) : null;
+    if (!field || !rules) return json({ error: say.notUploadField }, 400);
+    if (!rules.mimeTypes.includes(type)) return json({ error: rules.typeMessage }, 415);
+    if (typeof size !== "number" || !Number.isInteger(size) || size < 1 || size > rules.maxBytes) {
+      return json({ error: rules.sizeMessage }, 413);
+    }
+    let editOf = null;
+    if (editing) {
+      const secret = typeof options.edit?.secret === "function" ? options.edit.secret() : options.edit?.secret;
+      const claims = options.edit ? await verifyEditToken(
+        typeof body["edit"] === "string" ? body["edit"] : null,
+        secret,
+        options.now ? { now: options.now().getTime() } : {}
+      ) : null;
+      if (!claims || form.allowsEdits !== true) return json({ error: say.badEditLink, code: "bad_link" }, 403);
+      let stored;
+      try {
+        stored = await options.edit.response(claims.id, form);
+      } catch {
+        log(`Loading response ${claims.id} for an upload failed.`);
+        return json({ error: say.failed }, 503);
+      }
+      if (!stored || stored.editNonce !== claims.nonce) return json({ error: say.badEditLink, code: "bad_link" }, 403);
+      editOf = stored.id;
+    }
+    if (options.rateLimit) {
+      const limit = options.rateLimit;
+      const key = await rateLimitKey({
+        kind: "upload",
+        scope: form.scope,
+        ip: clientIp(request.headers, limit.trustedIpHeaders ?? DEFAULT_TRUSTED_IP_HEADERS),
+        secret: limit.secret
+      });
+      const allowed = await allow(
+        limit.store,
+        {
+          key,
+          limit: limit.limit ?? RATE_LIMIT_DEFAULTS.upload.limit,
+          windowSeconds: limit.windowSeconds ?? RATE_LIMIT_DEFAULTS.upload.windowSeconds
+        },
+        { log, message: "The upload rate limit could not be checked; letting the upload through." }
+      );
+      if (!allowed) return json({ error: say.rateLimited }, 429);
+    }
+    const fileName = name || "photo";
+    try {
+      const begun = await options.store.beginUpload({
+        formId: form.id,
+        fieldId: field.id,
+        name: fileName,
+        contentType: type,
+        size,
+        attemptHash: editOf ? null : await hash(attemptId),
+        editOf
+      });
+      if ("tooMany" in begun) return json({ error: say.tooMany, code: "too_many_photos" }, 429);
+      const signed = await options.store.signUpload(begun.objectName);
+      return json({ ref: { id: begun.id, name: fileName, type, size }, upload: signed });
+    } catch (error) {
+      log(
+        `Starting an upload on ${form.label ?? form.id} for ${form.scope} failed: ${error instanceof Error ? error.message : "unexpected error"}`
+      );
+      return json({ error: say.failed }, 500);
+    }
+  };
+}
+
 // src/server.ts
 var MAX_EVENTS = 1e4;
 var MAX_SUBMISSION_VALUES = 2e5;
@@ -2881,21 +3101,29 @@ exports.EDIT_LINK_TTL_SECONDS = EDIT_LINK_TTL_SECONDS;
 exports.MAX_EVENTS = MAX_EVENTS;
 exports.MAX_REPLAY_WORK = MAX_REPLAY_WORK;
 exports.MAX_SUBMISSION_VALUES = MAX_SUBMISSION_VALUES;
+exports.MAX_UPLOAD_REQUEST_BYTES = MAX_UPLOAD_REQUEST_BYTES;
 exports.MIN_EDIT_SECRET_BYTES = MIN_EDIT_SECRET_BYTES;
+exports.NOT_UPLOADED_MESSAGE = NOT_UPLOADED_MESSAGE;
 exports.RATE_LIMIT_DEFAULTS = RATE_LIMIT_DEFAULTS;
 exports.RAW_EVENTS_PER_EVENT = RAW_EVENTS_PER_EVENT;
+exports.UPLOAD_MESSAGES = UPLOAD_MESSAGES;
 exports.addressPrefix = addressPrefix;
 exports.allow = allow;
 exports.answerSnapshots = answerSnapshots;
 exports.answersFromSnapshots = answersFromSnapshots;
+exports.attemptHash = attemptHash;
+exports.checkUploads = checkUploads;
 exports.clientIp = clientIp;
 exports.createEditSecretReader = createEditSecretReader;
+exports.createUploadHandler = createUploadHandler;
 exports.editLinkUrl = editLinkUrl;
 exports.isEditLinkRequest = isEditLinkRequest;
 exports.isUsableEditSecret = isUsableEditSecret;
 exports.publicDefinition = publicDefinition;
 exports.rateLimitKey = rateLimitKey;
 exports.signEditToken = signEditToken;
+exports.uploadFields = uploadFields;
+exports.uploadRules = uploadRules;
 exports.validateSubmission = validateSubmission;
 exports.verifyEditToken = verifyEditToken;
 exports.withEditLinkHeaders = withEditLinkHeaders;