@farm.js/core 0.1.0-beta.14 → 0.1.0-beta.16

package/dist/server-query.mjs

@@ -1,10 +1,10 @@
 import {
   FARM_SERVER_QUERY_SYMBOL,
   createServerQuery
-} from "./chunk-65A7QIKI.mjs";
-import "./chunk-VY2UYN5R.mjs";
+} from "./chunk-UMVLB3PN.mjs";
+import "./chunk-VPCFICID.mjs";
 import "./chunk-SCFX4UTD.mjs";
-import "./chunk-UB5UOSHB.mjs";
+import "./chunk-ZVMV3THA.mjs";
 import "./chunk-LM2YNO4U.mjs";
 import "./chunk-V3XURYJO.mjs";
 import "./chunk-WZ5QFROO.mjs";

package/dist/server.cjs

@@ -1919,6 +1919,47 @@ var init_cache_invalidation = __esm({
   }
 });
 
+// src/server-fn-error.ts
+function isServerFnFailure(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return candidate[FARM_SERVER_FN_FAILURE_SYMBOL] === true && candidate.name === "ServerFnFailure" && typeof candidate.code === "string" && Number.isInteger(candidate.status) && (candidate.status ?? 0) >= 400 && (candidate.status ?? 0) <= 599;
+}
+function serializeServerFnFailure(value) {
+  if (!isServerFnFailure(value)) return null;
+  return {
+    name: "ServerFnFailure",
+    message: value.message,
+    code: value.code,
+    status: value.status,
+    data: value.data
+  };
+}
+var FARM_SERVER_FN_FAILURE_SYMBOL, _ServerFnFailure, ServerFnFailure;
+var init_server_fn_error = __esm({
+  "src/server-fn-error.ts"() {
+    "use strict";
+    FARM_SERVER_FN_FAILURE_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn.failure");
+    _ServerFnFailure = class _ServerFnFailure extends Error {
+      constructor(code, data, options) {
+        super(options.message);
+        this.name = "ServerFnFailure";
+        this.code = code;
+        this.data = data;
+        this.status = options.status;
+        Object.defineProperty(this, FARM_SERVER_FN_FAILURE_SYMBOL, {
+          value: true,
+          enumerable: false
+        });
+      }
+    };
+    __name(_ServerFnFailure, "ServerFnFailure");
+    ServerFnFailure = _ServerFnFailure;
+    __name(isServerFnFailure, "isServerFnFailure");
+    __name(serializeServerFnFailure, "serializeServerFnFailure");
+  }
+});
+
 // src/server-action-security.ts
 function resolveServerActionsConfig(config) {
   const allowedOrigins = (config?.allowedOrigins ?? []).map(normalizeAllowedOriginPattern);
@@ -2005,7 +2046,9 @@ function createServerActionRequestErrorResponse(error) {
     headers
   });
 }
-function sanitizeServerActionError(_error) {
+function sanitizeServerActionError(error) {
+  const declaredFailure = serializeServerFnFailure(error);
+  if (declaredFailure) return declaredFailure;
   return {
     name: "ServerActionError",
     message: "Server function failed"
@@ -2304,6 +2347,7 @@ var init_server_action_security = __esm({
     "use strict";
     import_node_async_hooks = require("async_hooks");
     init_cache_invalidation();
+    init_server_fn_error();
     DEFAULT_SERVER_ACTION_BODY_SIZE_LIMIT = 1e6;
     _ServerActionRequestError = class _ServerActionRequestError extends Error {
       constructor(code, status, message) {
@@ -22961,6 +23005,15 @@ function routePatternToRouteLiteral(pattern) {
   return JSON.stringify(pattern);
 }
 __name(routePatternToRouteLiteral, "routePatternToRouteLiteral");
+function renderTypeUnion(values) {
+  return values.length <= 1 ? values[0] || "never" : `
+  | ${values.join("\n  | ")}`;
+}
+__name(renderTypeUnion, "renderTypeUnion");
+function renderTypeAlias(name, value) {
+  return `export type ${name} =${value.startsWith("\n") ? "" : " "}${value};`;
+}
+__name(renderTypeAlias, "renderTypeAlias");
 function createRoutePattern(route) {
   if (route.segments.length === 0) return "/";
   return "/" + route.segments.map((seg) => {
@@ -23023,9 +23076,9 @@ async function createRouteTypeDeclarations(options, outPath) {
   const typeLiterals = Array.from(new Set(sortedPatterns.flatMap(routePatternToTsTypeLiterals)));
   const patternLiterals = sortedPatterns.map(routePatternToRouteLiteral);
   const routeModulePatternLiterals = Array.from(routeModulePatterns).sort().map(routePatternToRouteLiteral);
-  const routePathType = suppressLintOnLink ? "string" : typeLiterals.length ? typeLiterals.join(" | ") : "never";
-  const routePatternType = suppressLintOnLink ? "string" : patternLiterals.length ? patternLiterals.join(" | ") : "never";
-  const routeModulePatternType = routeModulePatternLiterals.length ? routeModulePatternLiterals.join(" | ") : "never";
+  const routePathType = suppressLintOnLink ? "string" : renderTypeUnion(typeLiterals);
+  const routePatternType = suppressLintOnLink ? "string" : renderTypeUnion(patternLiterals);
+  const routeModulePatternType = renderTypeUnion(routeModulePatternLiterals);
   const routeTypesImportPath = `./${path14.basename(outPath).replace(/\.d\.ts$/, "")}`;
   const linkAugmentationBlock = suppressLintOnLink ? "" : `
 declare module "@farm.js/core/client" {
@@ -23067,9 +23120,9 @@ declare global {
  * Regenerated on dev start and when routes change.
  * Set suppressLintOnLink: true in farm.config.ts to accept any string on Link href.
  */
-export type RoutePath = ${routePathType};
-export type RoutePattern = ${routePatternType};
-export type RouteModulePattern = ${routeModulePatternType};${linkAugmentationBlock}${routeModuleAugmentationBlock}
+${renderTypeAlias("RoutePath", routePathType)}
+${renderTypeAlias("RoutePattern", routePatternType)}
+${renderTypeAlias("RouteModulePattern", routeModulePatternType)}${linkAugmentationBlock}${routeModuleAugmentationBlock}
 `;
   return content;
 }
@@ -23351,7 +23404,8 @@ async function generateFarmTypeArtifacts(options) {
   const sourceRoots = getFarmSourceRoots({ root, srcDir, layers: options.layers });
   const appDirs = getFarmAppDirectories({ root, srcDir, layers: options.layers });
   const result = {
-    apiRoutes: []
+    apiRoutes: [],
+    stalePaths: []
   };
   const unifiedTypesPath = (0, import_path8.join)(root, srcDir, "farm.d.ts");
   const shouldRefreshUnifiedTypes = shouldGenerateRoutes && !options.routeTypesOutFile || shouldGenerateEnv && !options.envTypesOutFile || shouldGenerateI18n && !options.i18nTypesOutFile;
@@ -23367,22 +23421,29 @@ async function generateFarmTypeArtifacts(options) {
     unifiedSections.push(await createRouteTypeDeclarations(routeOptions, unifiedTypesPath));
     result.routeTypesPath = unifiedTypesPath;
   } else if (shouldGenerateRoutes) {
-    result.routeTypesPath = await generateRouteTypes({
+    const routeOptions = {
       root,
       srcDir,
       outFile: options.routeTypesOutFile,
       extraRoutes: options.extraRoutes || [],
       suppressLintOnLink: options.suppressLintOnLink,
       sourceRoots
-    });
+    };
+    if (options.check) {
+      const routeTypesPath = resolveGeneratedPath(root, srcDir, options.routeTypesOutFile);
+      const content = await createRouteTypeDeclarations(routeOptions, routeTypesPath);
+      checkGeneratedFile(routeTypesPath, content, result.stalePaths);
+      result.routeTypesPath = routeTypesPath;
+    } else {
+      result.routeTypesPath = await generateRouteTypes(routeOptions);
+    }
   }
   if (shouldGenerateApi) {
     const generator = new APITypeGenerator(appDirs);
     const apiRoutes = generator.scanAPIRoutes();
     const apiTypesPath = options.apiTypesOutFile ? (0, import_path8.resolve)(root, options.apiTypesOutFile) : (0, import_path8.join)(root, srcDir, "lib", "api.generated.ts");
     const content = generator.generateAPIRouter(apiRoutes, { outFile: apiTypesPath });
-    (0, import_fs4.mkdirSync)((0, import_path8.dirname)(apiTypesPath), { recursive: true });
-    writeFileIfChanged(apiTypesPath, content);
+    writeOrCheckGeneratedFile(apiTypesPath, content, options.check, result.stalePaths);
     result.apiTypesPath = apiTypesPath;
     result.apiRoutes = apiRoutes;
   }
@@ -23400,36 +23461,63 @@ async function generateFarmTypeArtifacts(options) {
     );
     result.envTypesPath = unifiedTypesPath;
   } else if (shouldGenerateEnv) {
-    result.envTypesPath = await generateEnvTypes({
+    const envOptions = {
       root,
       srcDir,
       outFile: options.envTypesOutFile,
       configPath: options.configPath,
       layerConfigPaths: (options.layers ?? []).map((layer) => layer.configFile).filter((configFile) => Boolean(configFile))
-    });
+    };
+    if (options.check) {
+      const envTypesPath = resolveGeneratedPath(root, srcDir, options.envTypesOutFile);
+      checkGeneratedFile(
+        envTypesPath,
+        createEnvTypeDeclarations(envOptions, envTypesPath),
+        result.stalePaths
+      );
+      result.envTypesPath = envTypesPath;
+    } else {
+      result.envTypesPath = await generateEnvTypes(envOptions);
+    }
   }
   if (shouldGenerateImages && options.imageTypesOutFile) {
-    result.imageTypesPath = generateFarmImageTypes({
-      root,
-      srcDir,
-      outFile: options.imageTypesOutFile
-    });
+    const imageTypesPath = resolveGeneratedPath(root, srcDir, options.imageTypesOutFile, false);
+    if (options.check) {
+      checkGeneratedFile(imageTypesPath, createFarmImageTypeDeclarations(), result.stalePaths);
+      result.imageTypesPath = imageTypesPath;
+    } else {
+      result.imageTypesPath = generateFarmImageTypes({
+        root,
+        srcDir,
+        outFile: options.imageTypesOutFile
+      });
+    }
   }
   if (shouldRefreshUnifiedTypes && options.i18nConfig?.enabled && !options.i18nTypesOutFile) {
     const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
     unifiedSections.push(renderFarmI18nTypes(options.i18nConfig.locales, signatures));
     result.i18nTypesPath = unifiedTypesPath;
   } else if (shouldGenerateI18n && options.i18nConfig) {
-    result.i18nTypesPath = await generateFarmI18nTypes({
-      root,
-      srcDir,
-      config: options.i18nConfig,
-      outFile: options.i18nTypesOutFile
-    });
+    if (options.check) {
+      const i18nTypesPath = resolveGeneratedPath(root, srcDir, options.i18nTypesOutFile, false);
+      const { signatures } = await readFarmI18nCatalogs(options.i18nConfig);
+      checkGeneratedFile(
+        i18nTypesPath,
+        renderFarmI18nTypes(options.i18nConfig.locales, signatures),
+        result.stalePaths
+      );
+      result.i18nTypesPath = i18nTypesPath;
+    } else {
+      result.i18nTypesPath = await generateFarmI18nTypes({
+        root,
+        srcDir,
+        config: options.i18nConfig,
+        outFile: options.i18nTypesOutFile
+      });
+    }
   }
   if (shouldRefreshUnifiedTypes) {
-    (0, import_fs4.mkdirSync)((0, import_path8.dirname)(unifiedTypesPath), { recursive: true });
-    writeFileIfChanged(
+    writeOrCheckGeneratedFile(
       unifiedTypesPath,
       `/**
  * Generated by Farm.js. Do not edit.
@@ -23438,14 +23526,41 @@ async function generateFarmTypeArtifacts(options) {
 
 import "@farm.js/core/image";
 
-${unifiedSections.join("\n")}`
+${unifiedSections.map((section) => section.trimEnd()).join("\n\n")}
+`,
+      options.check,
+      result.stalePaths
     );
     result.typesPath = unifiedTypesPath;
-    removeLegacyTypeArtifacts(root, srcDir);
+    if (options.check) {
+      collectLegacyTypeArtifacts(root, srcDir, result.stalePaths);
+    } else {
+      removeLegacyTypeArtifacts(root, srcDir);
+    }
   }
   return result;
 }
 __name(generateFarmTypeArtifacts, "generateFarmTypeArtifacts");
+function resolveGeneratedPath(root, srcDir, outFile, relativeToSrc = true) {
+  if ((0, import_path8.isAbsolute)(outFile)) return (0, import_path8.resolve)(outFile);
+  return (0, import_path8.resolve)(root, relativeToSrc ? (0, import_path8.join)(srcDir, outFile) : outFile);
+}
+__name(resolveGeneratedPath, "resolveGeneratedPath");
+function writeOrCheckGeneratedFile(filePath, content, check, stalePaths) {
+  if (check) {
+    checkGeneratedFile(filePath, content, stalePaths);
+    return;
+  }
+  (0, import_fs4.mkdirSync)((0, import_path8.dirname)(filePath), { recursive: true });
+  writeFileIfChanged(filePath, content);
+}
+__name(writeOrCheckGeneratedFile, "writeOrCheckGeneratedFile");
+function checkGeneratedFile(filePath, content, stalePaths) {
+  if (!(0, import_fs4.existsSync)(filePath) || (0, import_fs4.readFileSync)(filePath, "utf8") !== content) {
+    stalePaths.push(filePath);
+  }
+}
+__name(checkGeneratedFile, "checkGeneratedFile");
 var LEGACY_TYPE_ARTIFACTS = [
   ["farm-routes.d.ts", "Auto-generated route types"],
   ["farm-env.d.ts", "Auto-generated env types"],
@@ -23463,6 +23578,14 @@ function removeLegacyTypeArtifacts(root, srcDir) {
   }
 }
 __name(removeLegacyTypeArtifacts, "removeLegacyTypeArtifacts");
+function collectLegacyTypeArtifacts(root, srcDir, stalePaths) {
+  for (const [fileName, marker] of LEGACY_TYPE_ARTIFACTS) {
+    const filePath = (0, import_path8.join)(root, srcDir, fileName);
+    if (!(0, import_fs4.existsSync)(filePath)) continue;
+    if ((0, import_fs4.readFileSync)(filePath, "utf8").includes(marker)) stalePaths.push(filePath);
+  }
+}
+__name(collectLegacyTypeArtifacts, "collectLegacyTypeArtifacts");
 
 // src/vite.ts
 init_markdown();
@@ -23818,7 +23941,7 @@ function transformError(id, message) {
 __name(transformError, "transformError");
 
 // package.json
-var version = "0.1.0-beta.14";
+var version = "0.1.0-beta.16";
 
 // src/version.ts
 var FARM_VERSION = version;
@@ -27980,6 +28103,8 @@ init_server_action_security();
 
 // src/server-fn.ts
 init_server_action_security();
+init_server_fn_error();
+init_server_fn_error();
 var FARM_SERVER_FN_SYMBOL = /* @__PURE__ */ Symbol.for("farm.server-fn");
 var UNSAFE_FORM_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function createServerFn(options) {
@@ -27987,6 +28112,8 @@ function createServerFn(options) {
     throw new TypeError("createServerFn requires a handler function");
   }
   const middleware = resolveServerFnMiddleware(options.middleware);
+  const errors = normalizeServerFnErrors(options.errors);
+  const error = createServerFnErrorHandler(errors);
   const serverFn = /* @__PURE__ */ __name(async (value) => {
     const formData = isFormData(value) ? value : void 0;
     const rawInput = formData ? formDataToObject2(formData) : value;
@@ -28004,7 +28131,7 @@ function createServerFn(options) {
     let resolvedContext = Object.freeze(/* @__PURE__ */ Object.create(null));
     const result = await runServerFnMiddleware(middleware, handlerContext, async (context) => {
       resolvedContext = context.context;
-      return options.handler(context);
+      return options.handler({ ...context, error });
     });
     const parsedResult = await _parseServerFnSchema(options.output, result, "output");
     if (options.invalidates) {
@@ -28034,6 +28161,10 @@ function createServerFn(options) {
       value: options.output,
       enumerable: false
     },
+    __farmServerFnError: {
+      value: void 0,
+      enumerable: false
+    },
     __farmServerFnMiddleware: {
       value: middleware,
       enumerable: false
@@ -28072,6 +28203,78 @@ async function runServerFnMiddleware(middleware, handlerContext, handler) {
   return dispatch(0, Object.freeze(/* @__PURE__ */ Object.create(null)));
 }
 __name(runServerFnMiddleware, "runServerFnMiddleware");
+function normalizeServerFnErrors(definitions) {
+  if (definitions === void 0) return Object.freeze({});
+  if (!isPlainServerFnObject(definitions)) {
+    throw new TypeError("createServerFn errors must be an object");
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [code, definition] of Object.entries(definitions)) {
+    if (!code.trim()) {
+      throw new TypeError("Server function error codes cannot be empty");
+    }
+    if (!definition || typeof definition !== "object") {
+      throw new TypeError(`Server function error "${code}" must be an object`);
+    }
+    if (!Number.isInteger(definition.status) || definition.status < 400 || definition.status > 599) {
+      throw new TypeError(
+        `Server function error "${code}" status must be an integer between 400 and 599`
+      );
+    }
+    if (!definition.data || typeof definition.data.parse !== "function" && typeof definition.data.safeParse !== "function") {
+      throw new TypeError(
+        `Server function error "${code}" data must provide synchronous parse() or safeParse()`
+      );
+    }
+    if (definition.message !== void 0 && typeof definition.message !== "string") {
+      throw new TypeError(`Server function error "${code}" message must be a string`);
+    }
+    normalized[code] = Object.freeze({ ...definition });
+  }
+  return Object.freeze(normalized);
+}
+__name(normalizeServerFnErrors, "normalizeServerFnErrors");
+function createServerFnErrorHandler(definitions) {
+  return ((code, data) => {
+    const definition = definitions[code];
+    if (!definition) {
+      throw new TypeError(`Server function error "${code}" is not declared`);
+    }
+    const parsed = parseServerFnFailureData(code, definition.data, data);
+    throw new ServerFnFailure(code, parsed, {
+      status: definition.status,
+      message: definition.message ?? "Server function failed"
+    });
+  });
+}
+__name(createServerFnErrorHandler, "createServerFnErrorHandler");
+function parseServerFnFailureData(code, schema, value) {
+  if (typeof schema.safeParse === "function") {
+    const result2 = schema.safeParse(value);
+    if (isPromiseLike2(result2)) {
+      throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+    }
+    return unwrapSafeParseResult(result2);
+  }
+  const result = schema.parse(value);
+  if (isPromiseLike2(result)) {
+    throw new TypeError(`Server function error "${code}" data schema must parse synchronously`);
+  }
+  return result;
+}
+__name(parseServerFnFailureData, "parseServerFnFailureData");
+function isPlainServerFnObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainServerFnObject, "isPlainServerFnObject");
+function isPromiseLike2(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function"
+  );
+}
+__name(isPromiseLike2, "isPromiseLike");
 function resolveServerFnMiddleware(middleware) {
   const resolved = [];
   const seen = /* @__PURE__ */ new Set();