@flaredev/core 0.10.0 → 0.12.0

package/dist/chunk-7NQIVWGG.js

@@ -0,0 +1,68 @@
+// src/problem.ts
+var PROBLEM_CODES = {
+  /** The body broke a field's rules. `issues` says which fields. */
+  validationFailed: "validation_failed",
+  /** A unique column already holds this value. `issues` names the column. */
+  uniqueViolation: "unique_violation",
+  /** Deleting this would orphan rows that point at it. */
+  stillReferenced: "still_referenced",
+  /** A relation field names a record that does not exist. */
+  relatedRecordMissing: "related_record_missing",
+  /** A value outside what its column accepts — an enum option that is not one. */
+  valueNotAllowed: "value_not_allowed",
+  /** No such record, or none this request may see. */
+  notFound: "not_found",
+  /** A query parameter is wrong. `issues` names the parameters. */
+  invalidQuery: "invalid_query",
+  /** The body was not JSON. */
+  invalidJson: "invalid_json",
+  /** The request did not say `Content-Type: application/json`. */
+  unsupportedMediaType: "unsupported_media_type",
+  /** A write from another origin: the CSRF guard. */
+  crossOriginBlocked: "cross_origin_blocked",
+  /** No session and no API key. */
+  unauthenticated: "unauthenticated",
+  /** Signed in, but this role may not do this. */
+  forbidden: "forbidden",
+  /** Refused by the security layer before the app saw it. */
+  accessDenied: "access_denied",
+  /** Too many requests. */
+  rateLimited: "rate_limited",
+  /** A signed storage URL that is missing, malformed, expired, or not for this operation. */
+  invalidToken: "invalid_token",
+  /** An upload past the limit the signed URL allows. */
+  payloadTooLarge: "payload_too_large",
+  /** An upload with no Content-Length, which cannot be checked against that limit. */
+  lengthRequired: "length_required",
+  /** A request that is wrong in a way none of the others describes. */
+  badRequest: "bad_request",
+  /** Something went wrong that the server does not explain. */
+  internal: "internal"
+};
+var ISSUE_CODES = {
+  /** Broke the field's own rules: a format, a length, a required value. */
+  invalid: "invalid",
+  /** A unique column already holds this. */
+  unique: "unique",
+  /** Set once and not changeable — an ownership column, for instance. */
+  immutable: "immutable",
+  /** A query parameter rather than a body field. */
+  invalidParameter: "invalid_parameter"
+};
+function wantsJson(request) {
+  const accept = request.headers.get("accept") ?? "";
+  if (/\bapplication\/json\b/i.test(accept)) return true;
+  if (/\btext\/html\b/i.test(accept)) return false;
+  return new URL(request.url).pathname.startsWith("/api/");
+}
+function problemResponse(status, error, code, issues, init) {
+  const body = issues?.length ? { error, code, issues } : { error, code };
+  return Response.json(body, { ...init, status });
+}
+
+export {
+  PROBLEM_CODES,
+  ISSUE_CODES,
+  wantsJson,
+  problemResponse
+};

package/dist/{chunk-TB53VHXY.js → chunk-BTVEH5AU.js}

@@ -1,3 +1,7 @@
+import {
+  parseRate
+} from "./chunk-I2HSIPCF.js";
+
 // src/resource/fields.ts
 var STRING_FORMATS = [
   "email",
@@ -160,13 +164,50 @@ var humanize = (value) => {
   const text = words(value).join(" ");
   return text ? text[0].toUpperCase() + text.slice(1) : text;
 };
-var UNCOUNTABLE = /* @__PURE__ */ new Set(["equipment", "information", "rice", "money", "species", "series", "fish", "sheep", "data", "news"]);
-var IRREGULAR = { person: "people", man: "men", woman: "women", child: "children", mouse: "mice" };
+var UNCOUNTABLE = /* @__PURE__ */ new Set(["equipment", "information", "rice", "money", "species", "series", "fish", "sheep", "data", "news", "staff"]);
+var IRREGULAR = {
+  person: "people",
+  man: "men",
+  woman: "women",
+  child: "children",
+  mouse: "mice",
+  // -f / -fe → -ves
+  shelf: "shelves",
+  half: "halves",
+  knife: "knives",
+  life: "lives",
+  leaf: "leaves",
+  loaf: "loaves",
+  wolf: "wolves",
+  wife: "wives",
+  calf: "calves",
+  self: "selves",
+  thief: "thieves",
+  elf: "elves",
+  // Latin endings an app meets in a catalogue or a lab
+  index: "indexes",
+  matrix: "matrices",
+  vertex: "vertices",
+  appendix: "appendices",
+  analysis: "analyses",
+  diagnosis: "diagnoses",
+  thesis: "theses",
+  basis: "bases",
+  crisis: "crises",
+  criterion: "criteria",
+  curriculum: "curricula",
+  syllabus: "syllabuses",
+  alumnus: "alumni",
+  campus: "campuses",
+  status: "statuses",
+  quiz: "quizzes"
+};
 function pluralize(value) {
-  const match = /([A-Za-z]+)$/.exec(value);
-  if (!match) return value;
-  const word = match[1];
-  const lower = word.toLowerCase();
+  if (!/[A-Za-z]$/.test(value)) return value;
+  const parts = words(value);
+  const lower = parts[parts.length - 1];
+  if (!lower) return value;
+  const word = value.slice(value.length - lower.length);
   const head = value.slice(0, value.length - word.length);
   const keepCase = (plural) => word[0] === word[0].toUpperCase() ? plural[0].toUpperCase() + plural.slice(1) : plural;
   if (UNCOUNTABLE.has(lower)) return value;
@@ -192,6 +233,17 @@ var ResourceDefinitionError = class extends Error {
   }
 };
 var IDENTIFIER = /^[a-z][A-Za-z0-9]*$/;
+function validateRateLimit(name, config) {
+  for (const [action, spec] of Object.entries(config)) {
+    if (typeof spec !== "string") continue;
+    try {
+      parseRate(spec);
+    } catch (error) {
+      throw new ResourceDefinitionError(name, `rateLimit.${action}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return config;
+}
 function defaultFieldLabel(key, field2) {
   return humanize(field2.kind === "belongsTo" ? key.replace(/Id$/, "") : key);
 }
@@ -237,7 +289,7 @@ function defineResource(config) {
     fail(`titleField "${config.titleField}" isn't a stored field.`);
   }
   const defaultSort = config.defaultSort ?? { field: "createdAt", direction: "desc" };
-  if (!["createdAt", "updatedAt"].includes(defaultSort.field) && !stored.some(([key]) => key === defaultSort.field)) {
+  if (!["id", "createdAt", "updatedAt"].includes(defaultSort.field) && !stored.some(([key]) => key === defaultSort.field)) {
     fail(`defaultSort field "${defaultSort.field}" isn't a stored field.`);
   }
   const perPage = config.perPage ?? 25;
@@ -257,6 +309,9 @@ function defineResource(config) {
     defaultSort,
     perPage,
     softDelete: config.softDelete === true,
+    // Parsed here rather than in the route, so a rate that cannot be read is an error at
+    // `flare gen` with the descriptor in front of you, not a surprise in production.
+    ...config.rateLimit ? { rateLimit: validateRateLimit(config.name, config.rateLimit) } : {},
     fields,
     $types: void 0
   };
@@ -266,6 +321,65 @@ function storedFields(resource) {
 }
 var columnName = (key) => snakeCase(key);
 
+// src/resource/conditions.ts
+function conditionHolds(condition, values) {
+  if (!condition) return true;
+  const actual = values[condition.field];
+  const text = actual === null || actual === void 0 ? "" : String(actual);
+  switch (condition.op) {
+    case "eq":
+      return text === String(condition.value);
+    case "ne":
+      return text !== String(condition.value);
+    case "in":
+      return (Array.isArray(condition.value) ? condition.value : [condition.value]).some((option) => String(option) === text);
+  }
+}
+function describeCondition(condition) {
+  const values = Array.isArray(condition.value) ? condition.value : [condition.value];
+  if (condition.op === "in") return `${condition.field} is one of ${values.join(", ")}`;
+  return `${condition.field} ${condition.op === "eq" ? "is" : "is not"} ${values[0]}`;
+}
+
+// src/resource/enum-member.ts
+var IDENTIFIER_CHAR = /[A-Za-z0-9_]/;
+function prismaEnumMember(option) {
+  let member = "";
+  for (const char of option) {
+    if (IDENTIFIER_CHAR.test(char)) member += char;
+    else if (char === "-" || char === " ") member += "_";
+    else member += `_${char.codePointAt(0).toString(16)}`;
+  }
+  return /^\d/.test(member) ? `v_${member}` : member;
+}
+function enumMemberCollision(options) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const option of options) {
+    const member = prismaEnumMember(option);
+    const first = seen.get(member);
+    if (first !== void 0) return { a: first, b: option, member };
+    seen.set(member, option);
+  }
+  return void 0;
+}
+function enumTranslations(fields) {
+  const out = {};
+  for (const [key, def] of fields) {
+    if (def.kind !== "enum") continue;
+    const options = def.options ?? [];
+    if (options.every((option) => prismaEnumMember(option) === option)) continue;
+    const toMember = {};
+    const toValue = {};
+    for (const option of options) {
+      const member = prismaEnumMember(option);
+      toMember[option] = member;
+      toValue[member] = option;
+    }
+    out[key] = { toMember, toValue };
+  }
+  return out;
+}
+
 // src/resource/formats.ts
 import {
   getCountries,
@@ -337,7 +451,27 @@ var isSlug = (value) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
 function slugify(value) {
   return value.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
-var isIpAddress = (value) => /^(?:\d{1,3}\.){3}\d{1,3}$/.test(value) ? value.split(".").every((part) => Number(part) <= 255) : /^[0-9a-f:]+$/i.test(value) && value.includes(":") && value.split("::").length <= 2;
+function isIpv4(value) {
+  if (!/^(?:\d{1,3}\.){3}\d{1,3}$/.test(value)) return false;
+  return value.split(".").every((part) => {
+    const num = Number(part);
+    return num >= 0 && num <= 255;
+  });
+}
+function isIpv6(value) {
+  if (!value || value.includes(":::")) return false;
+  const doubleColonParts = value.split("::");
+  if (doubleColonParts.length > 2) return false;
+  if (doubleColonParts.length === 2) {
+    const left = doubleColonParts[0] ? doubleColonParts[0].split(":") : [];
+    const right = doubleColonParts[1] ? doubleColonParts[1].split(":") : [];
+    if (left.length + right.length >= 8) return false;
+    return [...left, ...right].every((p) => /^[0-9a-f]{1,4}$/i.test(p));
+  }
+  const parts = value.split(":");
+  return parts.length === 8 && parts.every((p) => /^[0-9a-f]{1,4}$/i.test(p));
+}
+var isIpAddress = (value) => isIpv4(value) || isIpv6(value);
 var isUuid = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 function isTimezone(value) {
   try {
@@ -480,18 +614,238 @@ function createValidators(resource) {
         "This file wasn't uploaded for this field"
       );
     }
-    const value = def.required ? base : base.nullable();
+    const conditional2 = def.showWhen !== void 0;
+    const value = def.required && !conditional2 ? base : base.nullable();
     update[key] = value.optional();
     const hasDefault = "default" in def && def.default !== void 0;
-    create[key] = def.required && !hasDefault ? value : value.optional();
+    create[key] = def.required && !conditional2 && !hasDefault ? value : value.optional();
   }
+  const conditional = [...storedFields(resource)].flatMap(
+    ([key, def]) => def.showWhen ? [{ key, condition: def.showWhen, required: def.required !== false }] : []
+  );
+  const checkConditions = (partial) => (values, ctx) => {
+    for (const { key, condition, required } of conditional) {
+      if (!required) continue;
+      if (partial && !(condition.field in values) && !(key in values)) continue;
+      if (!conditionHolds(condition, values)) continue;
+      const supplied = values[key];
+      if (supplied === void 0 || supplied === null || supplied === "") {
+        ctx.addIssue({ code: "custom", path: [key], message: `Required when ${describeCondition(condition)}` });
+      }
+    }
+  };
   const unknownKeys = { error: (issue) => issue.code === "unrecognized_keys" ? `Unknown field(s): ${issue.keys?.join(", ")}` : void 0 };
   return {
-    create: z.strictObject(create, unknownKeys),
-    update: z.strictObject(update, unknownKeys)
+    create: z.strictObject(create, unknownKeys).superRefine(checkConditions(false)),
+    update: z.strictObject(update, unknownKeys).superRefine(checkConditions(true))
   };
 }
 
+// src/resource/relations.ts
+var RelationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RelationError";
+  }
+};
+var relationNameFor = (table, key) => `${table}_${columnName(key)}`;
+var AUTH_USER = "User";
+var isAuthUserTarget = (target) => target === AUTH_USER;
+var defaultAuthUserOnDelete = (required) => required ? "restrict" : "set null";
+function relationGraph(resources) {
+  const byName = new Map(resources.map((resource) => [resource.name, resource]));
+  const graph = { byResource: {}, pending: [] };
+  for (const resource of resources) {
+    const relations = { belongsTo: [], hasMany: [] };
+    for (const [key, def] of storedFields(resource)) {
+      if (def.kind !== "belongsTo") continue;
+      const authUser = isAuthUserTarget(def.target);
+      if (!authUser && !byName.has(def.target)) {
+        throw new RelationError(`${resource.name}.${key} belongs to "${def.target}", but there is no ${def.target} resource.`);
+      }
+      relations.belongsTo.push({
+        key,
+        name: key.replace(/Id$/, ""),
+        target: def.target,
+        required: def.required,
+        onDelete: def.onDelete ?? (authUser ? defaultAuthUserOnDelete(def.required) : "restrict"),
+        relationName: relationNameFor(resource.table, key)
+      });
+    }
+    graph.byResource[resource.name] = relations;
+  }
+  for (const resource of resources) {
+    for (const [key, def] of Object.entries(resource.fields)) {
+      if (def.kind !== "hasMany") continue;
+      const target = byName.get(def.target);
+      if (!target) {
+        graph.pending.push({ resource: resource.name, key, target: def.target });
+        continue;
+      }
+      const foreignKey = def.foreignKey ?? `${camelCase(resource.name)}Id`;
+      const back = graph.byResource[target.name].belongsTo.find((relation) => relation.key === foreignKey);
+      if (!back || back.target !== resource.name) {
+        throw new RelationError(
+          `${resource.name}.${key} is hasMany(${target.name}), but ${target.name} has no ${foreignKey}: belongsTo(${resource.name}) field. Add it to ${target.name}, or set foreignKey to the field that points back.`
+        );
+      }
+      graph.byResource[resource.name].hasMany.push({ key, target: target.name, foreignKey, relationName: back.relationName });
+    }
+  }
+  for (const resource of resources) {
+    const { belongsTo, hasMany } = graph.byResource[resource.name];
+    const taken = new Set(Object.keys(resource.fields));
+    for (const { key, name } of belongsTo) {
+      if (taken.has(name)) {
+        throw new RelationError(`${resource.name}.${key} exposes relation "${name}", which collides with the ${resource.name}.${name} field. Rename one of them.`);
+      }
+      taken.add(name);
+    }
+    for (const { key } of hasMany) {
+      if (belongsTo.some((relation) => relation.name === key)) {
+        throw new RelationError(`${resource.name}.${key} collides with a belongsTo relation of the same name.`);
+      }
+    }
+  }
+  return graph;
+}
+
+// src/resource/display.ts
+var TONES = [
+  ["success", /^(paid|fulfilled|active|approved|completed?|delivered|done|published|resolved|shipped|succeeded|success|verified|won)$/],
+  ["danger", /^(banned|blocked|cancel+ed|churned|declined|error|expired|failed|lost|overdue|refunded|rejected|suspended)$/],
+  ["warning", /^(awaiting|draft|in[-_ ]?review|on[-_ ]?hold|pending|processing|review|trial|unpaid|unverified)$/]
+];
+function statusTone(value) {
+  if (typeof value !== "string") return "neutral";
+  const normalized = value.trim().toLowerCase();
+  return TONES.find(([, pattern]) => pattern.test(normalized))?.[0] ?? "neutral";
+}
+function optionLabel(def, value) {
+  if ((def.kind === "enum" || def.kind === "multiselect") && def.optionLabels?.[value]) return def.optionLabels[value];
+  const text = value.replace(/[_-]+/g, " ").trim();
+  return text ? text[0].toUpperCase() + text.slice(1) : value;
+}
+function formatValue(def, value, options = {}) {
+  if (value === null || value === void 0 || value === "") return "\u2014";
+  const locale = options.locale ?? "en-US";
+  switch (def.kind) {
+    case "boolean":
+      return value ? "Yes" : "No";
+    case "int":
+      return new Intl.NumberFormat(locale, { maximumFractionDigits: 0 }).format(Number(value));
+    case "float":
+      return new Intl.NumberFormat(locale, { maximumFractionDigits: 2 }).format(Number(value));
+    case "date": {
+      const date = /* @__PURE__ */ new Date(`${String(value)}T00:00:00Z`);
+      return Number.isNaN(date.getTime()) ? String(value) : new Intl.DateTimeFormat(locale, { dateStyle: "medium", timeZone: "UTC" }).format(date);
+    }
+    case "datetime":
+    case "timestamp": {
+      const date = value instanceof Date ? value : new Date(value);
+      return Number.isNaN(date.getTime()) ? String(value) : new Intl.DateTimeFormat(locale, { dateStyle: "medium", timeStyle: "short", timeZone: options.timeZone ?? "UTC" }).format(date);
+    }
+    case "enum":
+      return optionLabel(def, String(value));
+    case "multiselect":
+      return Array.isArray(value) && value.length ? value.map((item) => optionLabel(def, String(item))).join(", ") : "\u2014";
+    case "tags":
+      return Array.isArray(value) && value.length ? value.map(String).join(", ") : "\u2014";
+    case "json": {
+      if (value === null || value === void 0) return "\u2014";
+      const text = typeof value === "string" ? value : JSON.stringify(value);
+      return text.length > 60 ? `${text.slice(0, 59)}\u2026` : text;
+    }
+    case "string":
+      if (def.format === "tel") return formatPhone(String(value));
+      if (def.format === "country") return `${flagEmoji(String(value))} ${countryName(String(value), locale.split("-")[0])}`.trim();
+      return String(value);
+    case "file":
+      return String(value).split("/").pop().replace(/^[0-9a-f-]{36}-/, "");
+    default:
+      return String(value);
+  }
+}
+
+// src/resource/form.ts
+function initialFormValues(resource, record) {
+  const values = {};
+  for (const [key, def] of storedFields(resource)) {
+    const source = record ? record[key] : "default" in def ? def.default : void 0;
+    if (def.kind === "boolean") values[key] = source === true || source === 1;
+    else if (def.kind === "multiselect" || def.kind === "tags") values[key] = JSON.stringify(Array.isArray(source) ? source : []);
+    else if (def.kind === "json") values[key] = source === null || source === void 0 ? "" : JSON.stringify(source, null, 2);
+    else if (source === null || source === void 0) values[key] = "";
+    else if (source instanceof Date) values[key] = source.toISOString();
+    else values[key] = String(source);
+  }
+  return values;
+}
+function formValuesToInput(resource, values, mode) {
+  const input = {};
+  for (const [key, def] of storedFields(resource)) {
+    const raw = values[key];
+    if (def.kind === "boolean") {
+      input[key] = raw === true;
+      continue;
+    }
+    if (def.kind === "multiselect" || def.kind === "tags") {
+      const picked = parseMultiValue(raw);
+      if (picked.length === 0 && mode === "create" && "default" in def && def.default !== void 0) continue;
+      input[key] = picked.length === 0 && !def.required ? null : picked;
+      continue;
+    }
+    if (def.kind === "json") {
+      const source = typeof raw === "string" ? raw.trim() : "";
+      if (source === "") {
+        if (mode === "create" && "default" in def && def.default !== void 0) continue;
+        if (!def.required) input[key] = null;
+        continue;
+      }
+      try {
+        input[key] = JSON.parse(source);
+      } catch {
+        input[key] = Number.NaN;
+      }
+      continue;
+    }
+    const text = typeof raw === "string" ? raw : "";
+    const empty = text.trim() === "";
+    if (empty) {
+      const hasDefault = "default" in def && def.default !== void 0;
+      if (mode === "create" && hasDefault) continue;
+      if (!def.required) input[key] = null;
+      else if (def.kind === "string" || def.kind === "text") input[key] = text;
+      continue;
+    }
+    if (def.kind === "int" || def.kind === "float") {
+      const number = Number(text.trim());
+      input[key] = Number.isFinite(number) ? number : text;
+      continue;
+    }
+    input[key] = text;
+  }
+  return input;
+}
+function parseMultiValue(raw) {
+  if (typeof raw !== "string" || raw === "") return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((value) => typeof value === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function issuesByField(issues) {
+  const errors = {};
+  for (const issue of issues) {
+    const path = Array.isArray(issue.path) ? issue.path.map(String).join(".") : issue.path;
+    const key = path.split(".")[0] || "_form";
+    errors[key] ??= issue.message;
+  }
+  return errors;
+}
+
 // src/resource/policy.ts
 var ROLE = /^(\*|[a-z][a-z0-9_-]{0,31})$/;
 var FIELD = /^[a-z][A-Za-z0-9]*$/;
@@ -581,6 +935,11 @@ export {
   defineResource,
   storedFields,
   columnName,
+  conditionHolds,
+  describeCondition,
+  prismaEnumMember,
+  enumMemberCollision,
+  enumTranslations,
   flagEmoji,
   countryName,
   countries,
@@ -597,6 +956,18 @@ export {
   fieldSchema,
   fileKeyPrefix,
   createValidators,
+  RelationError,
+  AUTH_USER,
+  isAuthUserTarget,
+  defaultAuthUserOnDelete,
+  relationGraph,
+  statusTone,
+  optionLabel,
+  formatValue,
+  initialFormValues,
+  formValuesToInput,
+  parseMultiValue,
+  issuesByField,
   PolicyError,
   definePolicy,
   can,

package/dist/chunk-I2HSIPCF.js

@@ -0,0 +1,65 @@
+// src/rate-limit.ts
+var WINDOWS = {
+  s: 1,
+  sec: 1,
+  secs: 1,
+  second: 1,
+  seconds: 1,
+  m: 60,
+  min: 60,
+  mins: 60,
+  minute: 60,
+  minutes: 60,
+  h: 3600,
+  hr: 3600,
+  hour: 3600,
+  hours: 3600,
+  d: 86400,
+  day: 86400,
+  days: 86400
+};
+var RateSyntaxError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RateSyntaxError";
+  }
+};
+function parseRate(spec) {
+  const match = /^\s*(\d+)\s*\/\s*(\d*)\s*([a-z]+)\s*$/i.exec(spec);
+  if (!match) {
+    throw new RateSyntaxError(`"${spec}" is not a rate. Write it as calls/window, e.g. "10/min", "5/s" or "30/5min".`);
+  }
+  const limit = Number(match[1]);
+  const count = match[2] === "" ? 1 : Number(match[2]);
+  const unit = WINDOWS[match[3].toLowerCase()];
+  if (unit === void 0) {
+    throw new RateSyntaxError(`"${spec}" uses an unknown window "${match[3]}". Use s, min, hour or day.`);
+  }
+  if (limit < 1) throw new RateSyntaxError(`"${spec}" allows no calls at all. To forbid an action, use a policy instead of a rate limit.`);
+  if (count < 1) throw new RateSyntaxError(`"${spec}" has a window of zero.`);
+  return { limit, seconds: count * unit };
+}
+function rateFor(config, action) {
+  if (!config) return void 0;
+  const spec = config[action] ?? config["*"];
+  return spec === void 0 ? void 0 : parseRate(spec);
+}
+function ratesIn(config) {
+  if (!config) return [];
+  return Object.entries(config).filter(([, spec]) => typeof spec === "string").map(([action, spec]) => ({ action, spec, rate: parseRate(spec) }));
+}
+var rateLimitKey = (resource, action, caller) => `${resource}:${action}:${caller}`;
+async function fixedWindow(rate, increment) {
+  const { count, ttl } = await increment(rate.seconds);
+  const remaining = Math.max(0, rate.limit - count);
+  return { allowed: count <= rate.limit, remaining, retryAfter: Math.max(1, Math.ceil(ttl)) };
+}
+
+export {
+  RateSyntaxError,
+  parseRate,
+  rateFor,
+  ratesIn,
+  rateLimitKey,
+  fixedWindow
+};