@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-J3LOGE4T.cjs

@@ -0,0 +1,42 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkRG3ZOTG5cjs = require('./chunk-RG3ZOTG5.cjs');
+
+
+var _chunk5ZSWG4UXcjs = require('./chunk-5ZSWG4UX.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/headers.ts
+function headers() {
+  return new Headers(_chunk5ZSWG4UXcjs.getCurrentRequest.call(void 0, ).headers);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, headers, "headers");
+function cookies() {
+  const cookieHeader = _chunk5ZSWG4UXcjs.getCurrentRequest.call(void 0, ).headers.get("cookie") || "";
+  const parsed = _chunkRG3ZOTG5cjs.parseRequestCookieHeader.call(void 0, cookieHeader);
+  return {
+    get(name) {
+      return parsed.find((cookie) => cookie.name === name);
+    },
+    getAll(name) {
+      return name ? parsed.filter((cookie) => cookie.name === name) : [...parsed];
+    },
+    has(name) {
+      return parsed.some((cookie) => cookie.name === name);
+    },
+    toString() {
+      return cookieHeader;
+    },
+    [Symbol.iterator]() {
+      return parsed[Symbol.iterator]();
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, cookies, "cookies");
+
+
+
+
+exports.headers = headers; exports.cookies = cookies;

package/dist/chunk-J7FSKED3.cjs

@@ -0,0 +1,93 @@
+"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; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client-cancellation.ts
+function createClientCancellation(signal, timeoutMs = 0, parent) {
+  let timer;
+  let invalid;
+  let timeoutReason;
+  const signals = [signal, parent].filter((value) => !!value);
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 2147483647) {
+    invalid = new RangeError(
+      "timeoutMs must be an integer between 0 and 2147483647 (0 disables the deadline)."
+    );
+  } else if (timeoutMs > 0) {
+    const controller = new AbortController();
+    signals.push(controller.signal);
+    timer = setTimeout(() => {
+      timeoutReason = new DOMException("Client request timed out", "TimeoutError");
+      controller.abort(timeoutReason);
+    }, timeoutMs);
+  }
+  const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+  let active = 0;
+  let closed = false;
+  const cleanup = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (closed && active === 0 && timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  }, "cleanup");
+  const check = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    if (invalid) throw invalid;
+    _optionalChain([combined, 'optionalAccess', _ => _.throwIfAborted, 'call', _2 => _2()]);
+  }, "check");
+  return {
+    signal: combined,
+    get timedOut() {
+      return timeoutReason !== void 0 && _optionalChain([combined, 'optionalAccess', _3 => _3.reason]) === timeoutReason;
+    },
+    check,
+    hold() {
+      active++;
+      return () => {
+        active--;
+        cleanup();
+      };
+    },
+    // A race also bounds cooperative local dispatch and custom HTTP implementations.
+    // Late completion is consumed, but cannot turn a cancelled result into success.
+    async run(work) {
+      check();
+      active++;
+      let abort;
+      try {
+        if (!combined) return await work();
+        return await new Promise((resolve, reject) => {
+          abort = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => reject(combined.reason), "abort");
+          combined.addEventListener("abort", abort, { once: true });
+          Promise.resolve().then(() => {
+            check();
+            return work();
+          }).then(resolve, reject);
+        });
+      } finally {
+        if (abort) _optionalChain([combined, 'optionalAccess', _4 => _4.removeEventListener, 'call', _5 => _5("abort", abort)]);
+        active--;
+        cleanup();
+      }
+    },
+    async delay(ms) {
+      let retryTimer;
+      try {
+        await this.run(
+          () => new Promise((resolve) => {
+            retryTimer = setTimeout(resolve, ms);
+          })
+        );
+      } finally {
+        if (retryTimer !== void 0) clearTimeout(retryTimer);
+      }
+    },
+    dispose() {
+      closed = true;
+      cleanup();
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createClientCancellation, "createClientCancellation");
+
+
+
+exports.createClientCancellation = createClientCancellation;

package/dist/chunk-JDNHKPTD.cjs

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/secret-compare.ts
+function farmSecretsMatch(provided, expected) {
+  if (typeof provided !== "string" || typeof expected !== "string") return false;
+  if (expected.length === 0) return false;
+  let mismatch = provided.length ^ expected.length;
+  const length = Math.max(provided.length, expected.length);
+  for (let index = 0; index < length; index += 1) {
+    const providedCode = index < provided.length ? provided.charCodeAt(index) : 0;
+    const expectedCode = index < expected.length ? expected.charCodeAt(index) : 0;
+    mismatch |= providedCode ^ expectedCode;
+  }
+  return mismatch === 0;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, farmSecretsMatch, "farmSecretsMatch");
+
+
+
+exports.farmSecretsMatch = farmSecretsMatch;

package/dist/chunk-JSROZYYO.cjs

@@ -0,0 +1,164 @@
+"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; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/schema-capabilities.ts
+function assertNoSchemaListField(field, fieldPath, target) {
+  if (!field.list) {
+    return;
+  }
+  throw new Error(
+    `Schema field "${fieldPath}" declares list: true, but ${target} does not support list fields. Use type: "json" for an array value or model the values in a related table.`
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertNoSchemaListField, "assertNoSchemaListField");
+
+// src/schema-reference.ts
+function isDatabaseEnforcedReference(reference) {
+  return reference.enforced === void 0 || reference.enforced === "db";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isDatabaseEnforcedReference, "isDatabaseEnforcedReference");
+
+// 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.`
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertSupportedPrimaryKeyField, "assertSupportedPrimaryKeyField");
+
+// 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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, resolveSchemaModels, "resolveSchemaModels");
+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
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, cloneSchemaModel, "cloneSchemaModel");
+
+
+
+
+
+
+exports.assertNoSchemaListField = assertNoSchemaListField; exports.isDatabaseEnforcedReference = isDatabaseEnforcedReference; exports.assertSupportedPrimaryKeyField = assertSupportedPrimaryKeyField; exports.resolveSchemaModels = resolveSchemaModels;