@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-3UZVPO72.mjs

@@ -0,0 +1,387 @@
+import {
+  findProgrammaticRouteFilesInDir
+} from "./chunk-FSXSQQTV.mjs";
+import {
+  isFarmAPIRouteFileName
+} from "./chunk-YX6AFPXC.mjs";
+import {
+  _runWithFarmI18nRequest
+} from "./chunk-CV6MFQ4Y.mjs";
+import {
+  explainMissingOptionalPeer
+} from "./chunk-NR63PD3P.mjs";
+import {
+  API_ROUTE_METHODS,
+  getAllowedAPIRouteMethods,
+  invokeAPIRouteEndpoint,
+  matchAPIRouteAtBasePath,
+  mergePluginAPIRoutes,
+  resolveAPIRouteEndpoint
+} from "./chunk-ZFWYCVKS.mjs";
+import {
+  registerAPIRouteShape
+} from "./chunk-GWXZS7K5.mjs";
+import {
+  createProgrammaticRouteModuleId
+} from "./chunk-6YFC3ZFX.mjs";
+import {
+  getFarmRouteRuntimeConfig,
+  normalizeFarmRouteRuntimeConfig
+} from "./chunk-EVMXPJCB.mjs";
+import {
+  toFileModuleUrl
+} from "./chunk-VHIXGZYH.mjs";
+import {
+  loadFarmDevModule
+} from "./chunk-TUOO6IK3.mjs";
+import {
+  logger
+} from "./chunk-JSDV2NUN.mjs";
+import {
+  AmbiguousRouteError,
+  NonTerminalCatchAllRouteError
+} from "./chunk-AYP2YFVN.mjs";
+
+// src/api/route-manager.ts
+import * as fs from "fs";
+import * as path from "path";
+var APIRouteConflictError = class extends Error {
+  constructor(routePath, method, existingFile, conflictingFile) {
+    super(
+      `Duplicate API route for ${method.toUpperCase()} ${routePath}: ${existingFile} conflicts with ${conflictingFile}`
+    );
+    this.name = "APIRouteConflictError";
+  }
+};
+var APIRouteManager = class {
+  constructor(appDir, viteServer, options = {}) {
+    this.routes = /* @__PURE__ */ new Map();
+    this.endpointSources = /* @__PURE__ */ new Map();
+    this.routeShapes = /* @__PURE__ */ new Map();
+    this.appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
+    this.viteServer = viteServer;
+    this.plugins = options.plugins ?? [];
+    this.throwOnLoadError = options.throwOnLoadError === true;
+    this.i18n = options.i18n;
+    this.bodySizeLimit = options.bodySizeLimit;
+    this.basePath = options.basePath;
+    this.dispatch = options.dispatch;
+  }
+  /** Every file the current handlers were loaded from: route files and root routes files. */
+  getSourceFiles() {
+    const files = /* @__PURE__ */ new Set();
+    for (const sources of this.endpointSources.values()) {
+      for (const { filePath } of sources.values()) files.add(filePath);
+    }
+    return files;
+  }
+  /**
+   * Discover route.ts files in /app/api and explicit endpoints in root routes.ts
+   */
+  async discoverRoutes() {
+    const previousRoutes = this.routes;
+    const previousEndpointSources = this.endpointSources;
+    const previousRouteShapes = this.routeShapes;
+    this.routes = /* @__PURE__ */ new Map();
+    this.endpointSources = /* @__PURE__ */ new Map();
+    this.routeShapes = /* @__PURE__ */ new Map();
+    try {
+      for (const appDir of this.appDirs) {
+        const apiDir = path.join(appDir, "api");
+        let routeFiles = [];
+        if (fs.existsSync(apiDir)) {
+          routeFiles = this.findRouteFiles(apiDir);
+        }
+        for (const filePath of routeFiles) {
+          await this.loadRoute(filePath, appDir);
+        }
+        await this.loadRootRoutes(appDir);
+        await this.loadProgrammaticApiRoutes(appDir);
+      }
+      this.routes = new Map(
+        mergePluginAPIRoutes([...this.routes.values()], this.plugins, void 0, {
+          bodySizeLimit: this.bodySizeLimit,
+          dispatch: this.dispatch
+        }).map((route) => [route.path, route])
+      );
+    } catch (error) {
+      this.routes = previousRoutes;
+      this.endpointSources = previousEndpointSources;
+      this.routeShapes = previousRouteShapes;
+      throw error;
+    }
+    if (process.env.FARM_VERBOSE) {
+      logger.success(`Discovered ${this.routes.size} API routes`);
+      for (const [routePath, route] of this.routes) {
+        logger.info(`  ${route.methods.join(", ")} ${routePath}`);
+      }
+    }
+  }
+  /**
+   * Recursively find all route.ts files
+   */
+  findRouteFiles(dir) {
+    const files = [];
+    if (!fs.existsSync(dir)) {
+      return files;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...this.findRouteFiles(fullPath));
+      } else if (isFarmAPIRouteFileName(entry.name)) {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+  /**
+   * Load a route.ts file and extract HTTP method exports
+   */
+  async loadRoute(filePath, appDir) {
+    try {
+      const apiDir = path.join(appDir, "api");
+      const relativePath = path.relative(apiDir, path.dirname(filePath));
+      const routePath = "/api/" + (relativePath === "." ? "" : relativePath.replace(/\\/g, "/"));
+      const routeModule = await this.loadModule(filePath);
+      const endpoints = {};
+      const availableMethods = [];
+      for (const method of API_ROUTE_METHODS) {
+        if (routeModule[method]) {
+          endpoints[method] = routeModule[method];
+          availableMethods.push(method);
+        }
+      }
+      if (availableMethods.length > 0) {
+        const existingSources = this.endpointSources.get(routePath);
+        if (existingSources) {
+          for (const method of availableMethods) {
+            const existingSource = existingSources.get(method);
+            if (existingSource?.appDir === appDir) {
+              throw new APIRouteConflictError(routePath, method, existingSource.filePath, filePath);
+            }
+          }
+        }
+        const runtimeConfig = normalizeFarmRouteRuntimeConfig(
+          getFarmRouteRuntimeConfig(routeModule),
+          `API route "${routePath}"`
+        );
+        this.registerRouteShape(routePath, filePath, appDir);
+        const existingRoute = this.routes.get(routePath);
+        const mergedMethods = existingRoute ? [...existingRoute.methods] : [];
+        for (const method of availableMethods) {
+          if (!mergedMethods.includes(method)) mergedMethods.push(method);
+        }
+        this.routes.set(routePath, {
+          ...existingRoute,
+          path: routePath,
+          filePath,
+          methods: mergedMethods,
+          endpoints: { ...existingRoute?.endpoints, ...endpoints },
+          ...runtimeConfig
+        });
+        const nextSources = new Map(existingSources);
+        for (const method of availableMethods) {
+          nextSources.set(method, { appDir, filePath });
+        }
+        this.endpointSources.set(routePath, nextSources);
+      }
+    } catch (error) {
+      this.handleLoadError(`Error loading route ${filePath}`, error);
+    }
+  }
+  /**
+   * Load explicit-path endpoints from src/routes.ts-style files.
+   */
+  async loadRootRoutes(appDir) {
+    const routesFile = this.findRootRoutesFile(appDir);
+    if (!routesFile) {
+      return;
+    }
+    try {
+      const routesModule = await this.loadModule(routesFile);
+      for (const exportValue of Object.values(routesModule)) {
+        const endpoint = exportValue;
+        if (!endpoint?.__path) {
+          continue;
+        }
+        const method = String(endpoint.__method || "GET").toUpperCase();
+        this.registerRouteShape(endpoint.__path, routesFile, appDir);
+        this.addEndpoint(endpoint.__path, routesFile, method, endpoint, appDir);
+      }
+    } catch (error) {
+      this.handleLoadError(`Error loading root API routes ${routesFile}`, error);
+    }
+  }
+  async loadProgrammaticApiRoutes(appDir) {
+    const candidateRoots = [path.dirname(appDir), appDir];
+    const routeFiles = Array.from(
+      new Set(candidateRoots.flatMap((srcRoot) => findProgrammaticRouteFilesInDir(srcRoot)))
+    );
+    if (routeFiles.length === 0) return;
+    const { getProgrammaticRouteManifest } = await import("./routes.mjs");
+    for (const routeFile of routeFiles) {
+      try {
+        const routesModule = await this.loadModule(routeFile);
+        const manifest = getProgrammaticRouteManifest(routesModule);
+        if (!manifest) continue;
+        for (const definition of manifest.routes) {
+          if (definition.kind !== "api") continue;
+          if (!Object.values(definition.methods).some(Boolean)) continue;
+          this.addProgrammaticApiRoute(routeFile, definition, appDir);
+        }
+      } catch (error) {
+        this.handleLoadError(`Error loading programmatic API routes ${routeFile}`, error);
+      }
+    }
+  }
+  handleLoadError(message, loadError) {
+    const error = explainMissingOptionalPeer(loadError, message.replace(/^Error loading /, ""));
+    logger.error(`${message}: ${error}`);
+    if (this.throwOnLoadError || error instanceof APIRouteConflictError || error instanceof AmbiguousRouteError || error instanceof NonTerminalCatchAllRouteError) {
+      throw error;
+    }
+  }
+  findRootRoutesFile(appDir) {
+    const routeNames = ["routes.ts", "routes.tsx", "routes.js"];
+    const candidateDirs = [path.dirname(appDir), appDir];
+    const seen = /* @__PURE__ */ new Set();
+    for (const dir of candidateDirs) {
+      for (const routeName of routeNames) {
+        const routesFile = path.join(dir, routeName);
+        if (seen.has(routesFile)) {
+          continue;
+        }
+        seen.add(routesFile);
+        if (fs.existsSync(routesFile)) {
+          return routesFile;
+        }
+      }
+    }
+    return null;
+  }
+  async loadModule(filePath) {
+    if (this.viteServer) {
+      return await loadFarmDevModule(this.viteServer, filePath);
+    }
+    return await import(
+      /* @vite-ignore */
+      toFileModuleUrl(filePath)
+    );
+  }
+  addEndpoint(routePath, filePath, method, endpoint, appDir, runtimeConfig = {}) {
+    const normalizedMethod = method.toUpperCase();
+    const existingRoute = this.routes.get(routePath);
+    const existingSource = this.endpointSources.get(routePath)?.get(normalizedMethod);
+    if (existingSource?.appDir === appDir) {
+      throw new APIRouteConflictError(
+        routePath,
+        normalizedMethod,
+        existingSource.filePath,
+        filePath
+      );
+    }
+    if (existingRoute) {
+      if (!existingRoute.methods.includes(normalizedMethod)) {
+        existingRoute.methods.push(normalizedMethod);
+      }
+      existingRoute.endpoints[normalizedMethod] = endpoint;
+      Object.assign(existingRoute, runtimeConfig);
+      const sources = this.endpointSources.get(routePath) ?? /* @__PURE__ */ new Map();
+      sources.set(normalizedMethod, { appDir, filePath });
+      this.endpointSources.set(routePath, sources);
+      return;
+    }
+    this.routes.set(routePath, {
+      path: routePath,
+      filePath,
+      methods: [normalizedMethod],
+      endpoints: { [normalizedMethod]: endpoint },
+      ...runtimeConfig
+    });
+    this.endpointSources.set(routePath, /* @__PURE__ */ new Map([[normalizedMethod, { appDir, filePath }]]));
+  }
+  addProgrammaticApiRoute(filePath, route, appDir) {
+    const modulePath = createProgrammaticRouteModuleId(filePath, "api", route.path);
+    const runtimeConfig = normalizeFarmRouteRuntimeConfig(route, `API route "${route.path}"`);
+    for (const [method, endpoint] of Object.entries(route.methods)) {
+      if (endpoint) {
+        this.addEndpoint(route.path, modulePath, method, endpoint, appDir, runtimeConfig);
+      }
+    }
+  }
+  registerRouteShape(routePath, filePath, appDir) {
+    const replacedPath = registerAPIRouteShape(this.routeShapes, routePath, filePath, appDir);
+    if (replacedPath) {
+      this.routes.delete(replacedPath);
+      this.endpointSources.delete(replacedPath);
+    }
+  }
+  /**
+   * Get the handler that directly invokes endpoint handlers
+   */
+  getHandler(options = {}) {
+    if (this.routes.size === 0) {
+      return null;
+    }
+    return async (request) => {
+      const url = new URL(request.url);
+      const pathname = url.pathname;
+      const method = request.method.toUpperCase();
+      const match = matchAPIRouteAtBasePath(this.routes, pathname, this.basePath);
+      if (!match) {
+        return new Response(JSON.stringify({ error: "Not Found" }), {
+          status: 404,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      const { route, params } = match;
+      const endpoint = resolveAPIRouteEndpoint(route, method);
+      if (!endpoint) {
+        return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+          status: 405,
+          headers: {
+            Allow: getAllowedAPIRouteMethods(route).join(", "),
+            "Content-Type": "application/json"
+          }
+        });
+      }
+      const invoke = async () => {
+        try {
+          return await invokeAPIRouteEndpoint(endpoint, request, params, this.bodySizeLimit);
+        } catch (error) {
+          if (options.throwOnError) throw error;
+          console.error(`[API Error] ${pathname}:`, error);
+          return new Response(JSON.stringify({ error: "Internal Server Error" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+          });
+        }
+      };
+      return this.i18n?.config.enabled ? _runWithFarmI18nRequest(this.i18n, request, invoke, {
+        redirect: false
+      }) : invoke();
+    };
+  }
+  /**
+   * Check if a path is an API route
+   */
+  isAPIRoute(pathname) {
+    return Boolean(this.matchRoute(pathname));
+  }
+  matchRoute(pathname) {
+    return matchAPIRouteAtBasePath(this.routes, pathname, this.basePath);
+  }
+  /**
+   * Get all routes for client type generation
+   */
+  getRoutes() {
+    return this.routes;
+  }
+};
+
+export {
+  APIRouteConflictError,
+  APIRouteManager
+};

package/dist/chunk-43V3ANPQ.mjs

@@ -0,0 +1,251 @@
+// src/mobile/native-specs.ts
+import { existsSync, realpathSync } from "fs";
+import { createRequire } from "module";
+import * as path from "path";
+var UnsupportedType = class extends Error {
+};
+var parsers = /* @__PURE__ */ new Map();
+function loadCodegen(root) {
+  const cached = parsers.get(root);
+  if (cached) return cached;
+  let codegenDir;
+  let load;
+  try {
+    let reactNative;
+    for (let dir = root; ; dir = path.dirname(dir)) {
+      const candidate = path.join(dir, "node_modules", "react-native", "package.json");
+      if (existsSync(candidate)) {
+        reactNative = realpathSync(candidate);
+        break;
+      }
+      if (path.dirname(dir) === dir) throw new Error(`react-native is not installed in ${root}.`);
+    }
+    load = createRequire(reactNative);
+    codegenDir = path.dirname(load.resolve("@react-native/codegen/package.json"));
+  } catch (error) {
+    throw Object.assign(
+      new Error(
+        "Reading a native module spec needs React Native's Codegen (@react-native/codegen, installed with react-native). Add react-native to the app's dependencies and install them."
+      ),
+      { cause: error }
+    );
+  }
+  const typescript = load(path.join(codegenDir, "lib/parsers/typescript/parser.js"));
+  const flow = load(path.join(codegenDir, "lib/parsers/flow/parser.js"));
+  const loaded = { typescript: new typescript.TypeScriptParser(), flow: new flow.FlowParser() };
+  parsers.set(root, loaded);
+  return loaded;
+}
+function hasFarmNativeCodegen(root) {
+  try {
+    loadCodegen(root);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function describe(annotation) {
+  switch (annotation.type) {
+    case "FunctionTypeAnnotation":
+      return "a callback";
+    case "MixedTypeAnnotation":
+      return "a mixed value";
+    case "ReservedTypeAnnotation":
+      return String(annotation.name ?? "a reserved type");
+    case "EventEmitterTypeAnnotation":
+      return "an event emitter";
+    default:
+      return annotation.type.replace(/TypeAnnotation$/, "");
+  }
+}
+function toType(annotation, module, options = {}) {
+  switch (annotation.type) {
+    case "NullableTypeAnnotation":
+      return {
+        ...toType(annotation.typeAnnotation, module, options),
+        nullable: true
+      };
+    case "StringTypeAnnotation":
+      return { type: "string" };
+    case "NumberTypeAnnotation":
+    case "DoubleTypeAnnotation":
+    case "FloatTypeAnnotation":
+      return { type: "number" };
+    case "Int32TypeAnnotation":
+      return { type: "number", integer: true };
+    case "BooleanTypeAnnotation":
+      return { type: "boolean" };
+    case "StringLiteralTypeAnnotation":
+    case "NumberLiteralTypeAnnotation":
+      return { type: "literal", values: [annotation.value] };
+    case "UnionTypeAnnotation":
+    case "StringLiteralUnionTypeAnnotation": {
+      const types = annotation.types ?? [];
+      const values = types.map((member) => member.value);
+      if (types.length > 0 && types.every(
+        (member) => member.type === "StringLiteralTypeAnnotation" || member.type === "NumberLiteralTypeAnnotation"
+      ) && (values.every((value) => typeof value === "string") || values.every((value) => typeof value === "number"))) {
+        return { type: "literal", values };
+      }
+      throw new UnsupportedType("a union that is not all string or all number literals");
+    }
+    case "EnumDeclaration": {
+      const members = module.enumMap?.[String(annotation.name)]?.members ?? [];
+      const values = members.map((member) => member.value?.value);
+      if (values.length > 0 && (values.every((value) => typeof value === "string") || values.every((value) => typeof value === "number"))) {
+        return { type: "literal", values };
+      }
+      throw new UnsupportedType(`the enum ${String(annotation.name)}`);
+    }
+    case "ObjectTypeAnnotation": {
+      const properties = annotation.properties ?? [];
+      return {
+        type: "object",
+        properties: properties.map((property) => ({
+          name: property.name,
+          optional: property.optional === true,
+          type: toType(property.typeAnnotation, module, options)
+        }))
+      };
+    }
+    case "TypeAliasTypeAnnotation": {
+      const alias = module.aliasMap?.[String(annotation.name)];
+      if (!alias) throw new UnsupportedType(`the unknown type ${String(annotation.name)}`);
+      return toType(alias, module, options);
+    }
+    case "GenericObjectTypeAnnotation":
+      return { type: "map" };
+    case "ArrayTypeAnnotation": {
+      const element = annotation.elementType;
+      if (!element || element.type === "AnyTypeAnnotation") return { type: "array" };
+      return { type: "array", element: toType(element, module, options) };
+    }
+    case "VoidTypeAnnotation":
+      if (options.returns) return { type: "void" };
+      break;
+  }
+  if (options.returns) return { type: "unknown" };
+  throw new UnsupportedType(describe(annotation));
+}
+function readFarmNativeWebSpec(options) {
+  const codegen = loadCodegen(options.root);
+  const parser = /\.tsx?$/.test(options.file) ? codegen.typescript : codegen.flow;
+  let schema;
+  try {
+    schema = parser.parseFile(options.file);
+  } catch (error) {
+    const shown = path.relative(options.root, options.file).split(path.sep).join("/");
+    throw Object.assign(
+      new Error(`React Native's Codegen rejected ${shown}: ${error.message}`),
+      { cause: error }
+    );
+  }
+  const module = Object.values(schema.modules).find((entry) => entry.type === "NativeModule");
+  const result = { methods: [], unsupported: [] };
+  for (const method of module?.spec?.methods ?? []) {
+    let fn = method.typeAnnotation;
+    if (fn.type === "NullableTypeAnnotation") fn = fn.typeAnnotation;
+    if (fn.type !== "FunctionTypeAnnotation") continue;
+    const returned = fn.returnTypeAnnotation;
+    if (returned?.type !== "PromiseTypeAnnotation") continue;
+    const params = fn.params ?? [];
+    try {
+      result.methods.push({
+        name: method.name,
+        params: params.map((param) => {
+          try {
+            return {
+              name: param.name,
+              optional: param.optional === true,
+              type: toType(param.typeAnnotation, module)
+            };
+          } catch (error) {
+            if (!(error instanceof UnsupportedType)) throw error;
+            throw new UnsupportedType(
+              `its parameter ${param.name} is ${error.message}, which a web screen cannot send`
+            );
+          }
+        }),
+        returns: toType(
+          returned.elementType ?? { type: "VoidTypeAnnotation" },
+          module,
+          { returns: true }
+        )
+      });
+    } catch (error) {
+      if (!(error instanceof UnsupportedType)) throw error;
+      result.unsupported.push({ method: method.name, reason: error.message });
+    }
+  }
+  return result;
+}
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function renderFarmNativeType(type) {
+  let rendered;
+  switch (type.type) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "void":
+    case "unknown":
+      rendered = type.type;
+      break;
+    case "literal":
+      rendered = type.values.map((value) => JSON.stringify(value)).join(" | ");
+      break;
+    case "map":
+      rendered = "Record<string, unknown>";
+      break;
+    case "array": {
+      const element = type.element ? renderFarmNativeType(type.element) : "unknown";
+      rendered = `Array<${element}>`;
+      break;
+    }
+    case "object":
+      rendered = type.properties.length ? `{ ${type.properties.map(
+        (property) => `${IDENTIFIER.test(property.name) ? property.name : JSON.stringify(property.name)}${property.optional ? "?" : ""}: ${renderFarmNativeType(property.type)}`
+      ).join("; ")} }` : "{}";
+      break;
+  }
+  return type.nullable ? `${rendered} | null` : rendered;
+}
+function renderFarmNativeMethod(method) {
+  const lastRequired = method.params.reduce(
+    (last, param, index) => param.optional ? last : index,
+    -1
+  );
+  const params = method.params.map((param, index) => {
+    const type = renderFarmNativeType(param.type);
+    if (!param.optional) return `${param.name}: ${type}`;
+    return index > lastRequired ? `${param.name}?: ${type}` : `${param.name}: ${type} | undefined`;
+  }).join(", ");
+  return `${method.name}(${params}): Promise<${renderFarmNativeType(method.returns)}>;`;
+}
+function createFarmNativeModuleTypeDeclarations(specs, options) {
+  if (specs.length === 0 || !hasFarmNativeCodegen(options.root)) return void 0;
+  const modules = specs.map((spec) => {
+    const { methods } = readFarmNativeWebSpec({ root: options.root, file: spec.file });
+    const body = methods.filter((method) => method.name !== "available").map((method) => `      ${renderFarmNativeMethod(method)}`).join("\n");
+    return `    ${spec.name}: {${body ? `
+${body}
+    ` : ""}};`;
+  });
+  return `/**
+ * Auto-generated from the Codegen specs in src/native: native.<module> from @farm.js/core/native.
+ * Web screens reach a module's Promise methods only when mobile.modules.<name>.web is true, and
+ * only inside the mobile shell; check native.<module>.available() first.
+ */
+declare module "@farm.js/core/native" {
+  interface FarmNativeModules {
+${modules.join("\n")}
+  }
+}`;
+}
+
+export {
+  hasFarmNativeCodegen,
+  readFarmNativeWebSpec,
+  renderFarmNativeType,
+  renderFarmNativeMethod,
+  createFarmNativeModuleTypeDeclarations
+};

package/dist/chunk-46P5KNTE.mjs

@@ -0,0 +1,8 @@
+// src/schema.ts
+function defineSchema(schema) {
+  return schema;
+}
+
+export {
+  defineSchema
+};