@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-GBMWLDCC.cjs

@@ -1,138 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/schema-primary-key.ts
-var SUPPORTED_PRIMARY_KEY_TYPES = /* @__PURE__ */ new Set(["id", "uuid", "string", "integer"]);
-function assertSupportedPrimaryKeyField(location, field) {
-  if (!field.primaryKey || SUPPORTED_PRIMARY_KEY_TYPES.has(field.type)) {
-    return;
-  }
-  throw new Error(
-    `Schema primary-key field "${location}" uses unsupported type "${field.type}". Supported types are id, uuid, string, and integer.`
-  );
-}
-
-// src/schema-resolve.ts
-function resolveSchemaModels(ownerKey, schema) {
-  const models = Object.fromEntries(
-    Object.entries(schema.models).map(([modelKey, model]) => [modelKey, cloneSchemaModel(model)])
-  );
-  for (const [modelKey, extension] of Object.entries(schema.extend || {})) {
-    const existing = models[modelKey];
-    models[modelKey] = {
-      ...existing || { fields: {} },
-      ...extension.name ? { name: extension.name } : {},
-      ...extension.description ? { description: extension.description } : {},
-      fields: {
-        ..._optionalChain([existing, 'optionalAccess', _ => _.fields]),
-        ...extension.fields
-      },
-      constraints: [..._optionalChain([existing, 'optionalAccess', _2 => _2.constraints]) || [], ...extension.constraints || []],
-      meta: {
-        ..._optionalChain([existing, 'optionalAccess', _3 => _3.meta]),
-        ...extension.meta
-      }
-    };
-  }
-  for (const [modelKey, override] of Object.entries(schema.override || {})) {
-    const existing = models[modelKey];
-    if (!existing) {
-      throw new Error(
-        `Schema override for "${ownerKey}.${modelKey}" is invalid because that model does not exist.`
-      );
-    }
-    const fields = {
-      ...existing.fields
-    };
-    for (const [fieldKey, fieldOverride] of Object.entries(override.fields || {})) {
-      const existingField = fields[fieldKey];
-      if (!existingField && !fieldOverride.type) {
-        throw new Error(
-          `Schema override for "${ownerKey}.${modelKey}.${fieldKey}" is missing a field type.`
-        );
-      }
-      fields[fieldKey] = {
-        ...existingField,
-        ...fieldOverride
-      };
-    }
-    models[modelKey] = {
-      ...existing,
-      ...override.name ? { name: override.name } : {},
-      ...override.description ? { description: override.description } : {},
-      fields,
-      constraints: override.constraints || existing.constraints,
-      meta: {
-        ...existing.meta,
-        ...override.meta
-      }
-    };
-  }
-  const resolvedModels = {};
-  for (const [modelKey, model] of Object.entries(models)) {
-    const modelName = model.name || modelKey;
-    const fieldNames = /* @__PURE__ */ new Set();
-    const resolvedFields = {};
-    for (const [fieldKey, field] of Object.entries(model.fields)) {
-      const fieldName = field.name || fieldKey;
-      assertSupportedPrimaryKeyField(`${ownerKey}.${modelKey}.${fieldKey}`, field);
-      if (fieldNames.has(fieldName)) {
-        throw new Error(
-          `Schema model "${ownerKey}.${modelKey}" contains duplicate field name "${fieldName}".`
-        );
-      }
-      fieldNames.add(fieldName);
-      resolvedFields[fieldKey] = {
-        ...field,
-        name: fieldName
-      };
-    }
-    const primaryKeyFields = Object.entries(resolvedFields).filter(([, field]) => field.primaryKey).map(([fieldKey]) => fieldKey);
-    if (primaryKeyFields.length > 1) {
-      throw new Error(
-        `Schema model "${ownerKey}.${modelKey}" defines multiple primary-key fields: ${primaryKeyFields.map((fieldKey) => `"${fieldKey}"`).join(", ")}. Composite primary keys are not supported.`
-      );
-    }
-    for (const constraint of model.constraints || []) {
-      for (const fieldKey of constraint.fields) {
-        if (!Object.prototype.hasOwnProperty.call(resolvedFields, fieldKey)) {
-          throw new Error(
-            `Schema ${constraint.type} constraint on "${ownerKey}.${modelKey}" references missing field "${fieldKey}".`
-          );
-        }
-      }
-    }
-    resolvedModels[modelKey] = {
-      ...model,
-      name: modelName,
-      fields: resolvedFields
-    };
-  }
-  for (const [modelKey, model] of Object.entries(resolvedModels)) {
-    for (const [fieldKey, field] of Object.entries(model.fields)) {
-      const reference = field.reference;
-      if (!reference || !Object.prototype.hasOwnProperty.call(resolvedModels, reference.model)) {
-        continue;
-      }
-      const referencedModel = resolvedModels[reference.model];
-      if (!Object.prototype.hasOwnProperty.call(referencedModel.fields, reference.field)) {
-        throw new Error(
-          `Schema reference "${ownerKey}.${modelKey}.${fieldKey}" targets missing field "${ownerKey}.${reference.model}.${reference.field}".`
-        );
-      }
-    }
-  }
-  return resolvedModels;
-}
-function cloneSchemaModel(model) {
-  return {
-    ...model,
-    fields: Object.fromEntries(
-      Object.entries(model.fields).map(([fieldKey, field]) => [fieldKey, { ...field }])
-    ),
-    constraints: model.constraints ? [...model.constraints] : void 0,
-    meta: model.meta ? { ...model.meta } : void 0
-  };
-}
-
-
-
-
-exports.assertSupportedPrimaryKeyField = assertSupportedPrimaryKeyField; exports.resolveSchemaModels = resolveSchemaModels;

package/dist/chunk-GFT5AHAT.mjs

@@ -1,423 +0,0 @@
-import {
-  copyRequestContext
-} from "./chunk-D2LCAV6L.mjs";
-import {
-  assertBrowserStableRoutePath
-} from "./chunk-AYP2YFVN.mjs";
-
-// src/server-http.ts
-function createFarmNodeRequestAbortSignal(req, res) {
-  const controller = new AbortController();
-  let disposed = false;
-  const dispose = () => {
-    if (disposed) return;
-    disposed = true;
-    req.off("aborted", abort);
-    res.off("close", abortOnEarlyClose);
-    res.off("finish", dispose);
-    controller.signal.removeEventListener("abort", dispose);
-  };
-  const abort = () => controller.abort();
-  const abortOnEarlyClose = () => {
-    if (!res.writableEnded) abort();
-    dispose();
-  };
-  if (req.aborted) {
-    controller.abort();
-    return controller.signal;
-  }
-  req.once("aborted", abort);
-  res.once("close", abortOnEarlyClose);
-  res.once("finish", dispose);
-  controller.signal.addEventListener("abort", dispose, { once: true });
-  return controller.signal;
-}
-var DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT = 1e7;
-var DEFAULT_FARM_SERVER_HEADERS_TIMEOUT = 6e4;
-var DEFAULT_FARM_SERVER_REQUEST_TIMEOUT = 3e5;
-var DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT = 5e3;
-var DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT = 3e4;
-var MAX_FARM_SERVER_TIMEOUT = 2147483647;
-function createFarmWeakETag(body) {
-  let hash = 2166136261;
-  for (let index = 0; index < body.length; index++) {
-    hash ^= body.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return `W/"${(hash >>> 0).toString(16).padStart(8, "0")}"`;
-}
-function matchesFarmIfNoneMatch(value, etag) {
-  const expected = parseEntityTag(trimOptionalWhitespace(etag));
-  if (!expected) return false;
-  const values = Array.isArray(value) ? value : [value];
-  const combined = values.filter((header) => typeof header === "string").join(",");
-  const fieldValue = trimOptionalWhitespace(combined);
-  if (!fieldValue) return false;
-  if (fieldValue === "*") return true;
-  let matched = false;
-  let hasEntityTag = false;
-  for (const candidate of splitEntityTags(fieldValue)) {
-    const token = trimOptionalWhitespace(candidate);
-    if (!token) continue;
-    const parsed = parseEntityTag(token);
-    if (!parsed) return false;
-    hasEntityTag = true;
-    if (parsed === expected) matched = true;
-  }
-  return hasEntityTag && matched;
-}
-function trimOptionalWhitespace(value) {
-  return value.replace(/^[\t ]+|[\t ]+$/g, "");
-}
-function parseEntityTag(value) {
-  const opaqueTag = value.startsWith("W/") ? value.slice(2) : value;
-  if (opaqueTag.length < 2 || opaqueTag[0] !== '"' || opaqueTag.at(-1) !== '"') return null;
-  for (let index = 1; index < opaqueTag.length - 1; index++) {
-    const code = opaqueTag.charCodeAt(index);
-    if (code === 33 || code >= 35 && code <= 126 || code >= 128) continue;
-    return null;
-  }
-  return opaqueTag;
-}
-function splitEntityTags(value) {
-  const tags = [];
-  let start = 0;
-  let quoted = false;
-  for (let index = 0; index < value.length; index++) {
-    const character = value[index];
-    if (character === '"') {
-      quoted = !quoted;
-    } else if (character === "," && !quoted) {
-      tags.push(value.slice(start, index));
-      start = index + 1;
-    }
-  }
-  tags.push(value.slice(start));
-  return tags;
-}
-var FarmRequestBodyError = class extends Error {
-  constructor(code, status, message) {
-    super(message);
-    this.name = "FarmRequestBodyError";
-    this.code = code;
-    this.status = status;
-  }
-};
-function resolveFarmServerConfig(config) {
-  const headersTimeout = parseFarmServerDuration(
-    config?.headersTimeout ?? DEFAULT_FARM_SERVER_HEADERS_TIMEOUT,
-    "server.headersTimeout"
-  );
-  const requestTimeout = parseFarmServerDuration(
-    config?.requestTimeout ?? DEFAULT_FARM_SERVER_REQUEST_TIMEOUT,
-    "server.requestTimeout"
-  );
-  if (headersTimeout > requestTimeout) {
-    throw new TypeError("server.headersTimeout must not exceed server.requestTimeout");
-  }
-  return Object.freeze({
-    bodySizeLimit: parseBodySizeLimit(
-      config?.bodySizeLimit ?? DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT,
-      "server.bodySizeLimit"
-    ),
-    trustProxy: config?.trustProxy === true,
-    headersTimeout,
-    requestTimeout,
-    keepAliveTimeout: parseFarmServerDuration(
-      config?.keepAliveTimeout ?? DEFAULT_FARM_SERVER_KEEP_ALIVE_TIMEOUT,
-      "server.keepAliveTimeout"
-    ),
-    gracefulShutdownTimeout: parseFarmServerDuration(
-      config?.gracefulShutdownTimeout ?? DEFAULT_FARM_SERVER_GRACEFUL_SHUTDOWN_TIMEOUT,
-      "server.gracefulShutdownTimeout"
-    ),
-    health: resolveFarmServerHealthConfig(config?.health)
-  });
-}
-function parseFarmServerDuration(value, optionName = "duration") {
-  if (typeof value === "number") {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new TypeError(`${optionName} must be a positive safe integer`);
-    }
-    if (value > MAX_FARM_SERVER_TIMEOUT) {
-      throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
-    }
-    return value;
-  }
-  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)$/);
-  if (!match) {
-    throw new TypeError(`${optionName} must be milliseconds or a duration such as "30s" or "2m"`);
-  }
-  const amount = Number(match[1]);
-  const unit = match[2];
-  const multiplier = unit === "ms" ? 1 : unit === "s" ? 1e3 : unit === "m" ? 6e4 : 36e5;
-  const milliseconds = Math.floor(amount * multiplier);
-  if (!Number.isSafeInteger(milliseconds) || milliseconds <= 0) {
-    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
-  }
-  if (milliseconds > MAX_FARM_SERVER_TIMEOUT) {
-    throw new TypeError(`${optionName} must not exceed ${MAX_FARM_SERVER_TIMEOUT} milliseconds`);
-  }
-  return milliseconds;
-}
-function resolveFarmServerHealthConfig(config) {
-  if (config === false || config && "enabled" in config && config.enabled === false) {
-    return Object.freeze({
-      enabled: false,
-      livenessPath: "/_farm/health/live",
-      readinessPath: "/_farm/health/ready"
-    });
-  }
-  const livenessPath = normalizeHealthPath(
-    config?.livenessPath ?? "/_farm/health/live",
-    "server.health.livenessPath"
-  );
-  const readinessPath = normalizeHealthPath(
-    config?.readinessPath ?? "/_farm/health/ready",
-    "server.health.readinessPath"
-  );
-  if (livenessPath === readinessPath) {
-    throw new TypeError("server.health livenessPath and readinessPath must be different");
-  }
-  return Object.freeze({ enabled: true, livenessPath, readinessPath });
-}
-function normalizeHealthPath(value, optionName) {
-  const path = value.trim();
-  if (!path.startsWith("/") || path.includes("?") || path.includes("#") || path.includes("*")) {
-    throw new TypeError(`${optionName} must be an absolute pathname without a query or wildcard`);
-  }
-  const normalized = path.length > 1 ? path.replace(/\/+$/, "") || "/" : path;
-  assertBrowserStableRoutePath(normalized);
-  return normalized;
-}
-function parseBodySizeLimit(value, optionName = "bodySizeLimit") {
-  if (typeof value === "number") {
-    if (!Number.isSafeInteger(value) || value <= 0) {
-      throw new TypeError(`${optionName} must be a positive safe integer`);
-    }
-    return value;
-  }
-  const match = value.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|kib|mib|gib)?$/);
-  if (!match) {
-    throw new TypeError(`${optionName} must be bytes or a size string such as "500kb" or "10mb"`);
-  }
-  const amount = Number(match[1]);
-  const unit = match[2] ?? "b";
-  const multiplier = {
-    b: 1,
-    kb: 1e3,
-    mb: 1e6,
-    gb: 1e9,
-    kib: 1024,
-    mib: 1048576,
-    gib: 1073741824
-  };
-  const bytes = Math.floor(amount * multiplier[unit]);
-  if (!Number.isSafeInteger(bytes) || bytes <= 0) {
-    throw new TypeError(`${optionName} must resolve to a positive safe integer`);
-  }
-  return bytes;
-}
-function withFarmRequestClientAddress(request, trustProxy, clientAddress) {
-  const requestWithShape = request;
-  if (!requestWithShape.socket) {
-    const forwardedFor = trustProxy ? request.headers.get("x-forwarded-for")?.split(",").at(-1)?.trim() : void 0;
-    try {
-      requestWithShape.socket = { remoteAddress: forwardedFor || clientAddress || void 0 };
-    } catch {
-    }
-  }
-  return requestWithShape;
-}
-function cloneFarmRequestWithContext(request) {
-  const cloned = request.clone();
-  copyRequestContext(request, cloned);
-  return cloned;
-}
-async function bufferFarmRequestBody(request, limit) {
-  if (request.method === "GET" || request.method === "HEAD" || request.body === null) {
-    return request;
-  }
-  const bytes = await readFarmRequestBody(request, limit);
-  const body = new Uint8Array(bytes.byteLength);
-  body.set(bytes);
-  const buffered = new Request(request, {
-    // oxlint-disable-next-line unicorn/no-invalid-fetch-options -- GET and HEAD return above.
-    body: body.buffer
-  });
-  copyRequestContext(request, buffered);
-  return buffered;
-}
-async function readFarmRequestBody(request, limit) {
-  try {
-    validateContentLength(request.headers.get("content-length"), limit);
-  } catch (error) {
-    void request.body?.cancel(error).catch(() => {
-    });
-    throw error;
-  }
-  throwIfAborted(request.signal);
-  if (!request.body) return new Uint8Array();
-  const reader = request.body.getReader();
-  const chunks = [];
-  let total = 0;
-  const cancelBodyRead = () => {
-    void reader.cancel(request.signal.reason).catch(() => {
-    });
-  };
-  request.signal.addEventListener("abort", cancelBodyRead, { once: true });
-  try {
-    while (true) {
-      throwIfAborted(request.signal);
-      const { done, value } = await reader.read();
-      throwIfAborted(request.signal);
-      if (done) break;
-      if (!value) continue;
-      total += value.byteLength;
-      if (total > limit) {
-        const error = new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-        void reader.cancel(error).catch(() => {
-        });
-        throw error;
-      }
-      chunks.push(value);
-    }
-  } catch (error) {
-    if (request.signal.aborted) throwIfAborted(request.signal);
-    throw error;
-  } finally {
-    request.signal.removeEventListener("abort", cancelBodyRead);
-    reader.releaseLock();
-  }
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return body;
-}
-var nodeRequestBodies = /* @__PURE__ */ new WeakMap();
-async function readNodeRequestBody(request, limit) {
-  let body = nodeRequestBodies.get(request);
-  if (!body) {
-    body = readNodeRequestBodyOnce(request, limit);
-    nodeRequestBodies.set(request, body);
-  }
-  const bytes = await body;
-  if (bytes.byteLength > limit) {
-    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-  }
-  return bytes;
-}
-async function readNodeRequestBodyOnce(request, limit) {
-  const rawContentLength = request.headers["content-length"];
-  const contentLength = Array.isArray(rawContentLength) ? rawContentLength[0] : rawContentLength;
-  try {
-    validateContentLength(contentLength, limit);
-  } catch (error) {
-    request.resume?.();
-    throw error;
-  }
-  return await new Promise((resolve, reject) => {
-    const chunks = [];
-    let total = 0;
-    let settled = false;
-    const cleanup = () => {
-      request.removeListener?.("data", onData);
-      request.removeListener?.("end", onEnd);
-      request.removeListener?.("error", onError);
-    };
-    const rejectOnce = (error) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      request.resume?.();
-      reject(error);
-    };
-    const onData = (chunk) => {
-      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      total += bytes.byteLength;
-      if (total > limit) {
-        rejectOnce(new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large"));
-        return;
-      }
-      chunks.push(bytes);
-    };
-    const onEnd = () => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      resolve(Buffer.concat(chunks, total));
-    };
-    const onError = (error) => rejectOnce(error);
-    request.on("data", onData);
-    request.on("end", onEnd);
-    request.on("error", onError);
-  });
-}
-function createFarmNodeRequestBodyStream(request) {
-  let iterator;
-  return new ReadableStream(
-    {
-      async pull(controller) {
-        iterator ?? (iterator = request[Symbol.asyncIterator]());
-        const { value, done } = await iterator.next();
-        if (done) {
-          controller.close();
-          return;
-        }
-        controller.enqueue(
-          value instanceof Uint8Array ? value : new TextEncoder().encode(String(value))
-        );
-      },
-      async cancel(reason) {
-        await iterator?.return?.(reason);
-      }
-    },
-    // No eager pull: the request stays untouched until the handler reads it.
-    { highWaterMark: 0 }
-  );
-}
-function createFarmRequestBodyErrorResponse(error) {
-  if (!(error instanceof FarmRequestBodyError)) return null;
-  return new Response(error.status === 413 ? "Payload Too Large" : "Bad Request", {
-    status: error.status,
-    headers: {
-      "cache-control": "no-store",
-      "content-type": "text/plain; charset=utf-8",
-      "x-content-type-options": "nosniff"
-    }
-  });
-}
-function validateContentLength(value, limit) {
-  const contentLength = value?.trim();
-  if (!contentLength) return;
-  if (!/^\d+$/.test(contentLength)) {
-    throw new FarmRequestBodyError("INVALID_CONTENT_LENGTH", 400, "Invalid content-length header");
-  }
-  if (Number(contentLength) > limit) {
-    throw new FarmRequestBodyError("BODY_TOO_LARGE", 413, "Request body is too large");
-  }
-}
-function throwIfAborted(signal) {
-  if (!signal.aborted) return;
-  if (signal.reason !== void 0) throw signal.reason;
-  throw new DOMException("The operation was aborted", "AbortError");
-}
-
-export {
-  createFarmNodeRequestAbortSignal,
-  DEFAULT_FARM_SERVER_BODY_SIZE_LIMIT,
-  createFarmWeakETag,
-  matchesFarmIfNoneMatch,
-  resolveFarmServerConfig,
-  parseBodySizeLimit,
-  withFarmRequestClientAddress,
-  cloneFarmRequestWithContext,
-  bufferFarmRequestBody,
-  readFarmRequestBody,
-  readNodeRequestBody,
-  createFarmNodeRequestBodyStream,
-  createFarmRequestBodyErrorResponse
-};