one 1.16.12 → 1.17.0

package/src/cli/generateBundlerConfig.ts

@@ -0,0 +1,339 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import nodeModule from 'node:module'
+import path from 'node:path'
+import colors from 'picocolors'
+import { getRouterRootFromOneOptions } from '../utils/getRouterRootFromOneOptions'
+import type { One } from '../vite/types'
+
+/**
+ * Marker that identifies a bundler config as One-generated. If the file
+ * still contains this marker we can safely regenerate it; if the user
+ * removed the marker we treat the file as customized and never overwrite.
+ */
+export const ONE_GENERATED_MARKER = '@one/generated bundler-config'
+
+export type OneBundlerConfigOptions = {
+  routerRoot?: string
+  ignoredRouteFiles?: Array<`**/*${string}`>
+  linking?: NonNullable<One.PluginOptions['router']>['linking']
+  setupFile?: One.PluginOptions['setupFile']
+}
+
+function buildBabelConfigContent({
+  eject,
+  options,
+}: {
+  eject: boolean
+  options: OneBundlerConfigOptions
+}) {
+  const header = eject
+    ? `// you own this file. edit freely — \`one\` will not regenerate it.
+// delegates to one/babel-preset which holds the canonical plugin chain.
+`
+    : `// ${ONE_GENERATED_MARKER}
+//
+// auto-generated by \`one patch\` on ci/eas workers when expo-updates is
+// in deps. delegates to one/babel-preset so expo export / eas update
+// use the same router/setup options as \`one dev\` and \`one build\`.
+//
+// to customize, delete this header and edit freely — re-runs will then
+// leave this file alone.
+`
+
+  return `${header}
+const oneBabelPreset = require('one/babel-preset')
+const preset = oneBabelPreset.default || oneBabelPreset
+const oneBundlerOptions = ${serializeBundlerConfigOptions(options)}
+
+module.exports = function (api) {
+  return preset(api, oneBundlerOptions)
+}
+`
+}
+
+function buildMetroConfigContent({
+  eject,
+  options,
+}: {
+  eject: boolean
+  options: OneBundlerConfigOptions
+}) {
+  const header = eject
+    ? `// you own this file. edit freely — \`one\` will not regenerate it.
+// withOne() invokes the same Metro pipeline One uses for production bundles.
+`
+    : `// ${ONE_GENERATED_MARKER}
+//
+// auto-generated by \`one patch\` on ci/eas workers when expo-updates is
+// in deps. delegates to one/metro-config which invokes the exact same
+// metro pipeline one uses for production native bundles with your
+// router/setup options — no separate expo/metro-config setup needed.
+//
+// to customize, delete this header and edit freely — re-runs will then
+// leave this file alone.
+`
+
+  return `${header}
+const { withOne } = require('one/metro-config')
+const oneBundlerOptions = ${serializeBundlerConfigOptions(options)}
+
+module.exports = withOne(__dirname, oneBundlerOptions)
+`
+}
+
+type FileSpec = {
+  name: string
+  getContent: (args: {
+    eject: boolean
+    options: OneBundlerConfigOptions
+  }) => string
+  conflicting: readonly string[]
+}
+
+const FILES: readonly FileSpec[] = [
+  {
+    name: 'babel.config.cjs',
+    getContent: buildBabelConfigContent,
+    conflicting: ['babel.config.js', 'babel.config.mjs', '.babelrc', '.babelrc.js'],
+  },
+  {
+    name: 'metro.config.cjs',
+    getContent: buildMetroConfigContent,
+    conflicting: ['metro.config.js', 'metro.config.mjs'],
+  },
+] as const
+
+function stripUndefined(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(stripUndefined)
+  }
+
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value)
+        .filter(([, entry]) => entry !== undefined)
+        .map(([key, entry]) => [key, stripUndefined(entry)])
+    )
+  }
+
+  return value
+}
+
+function assertSerializable(value: unknown, keyPath = 'one bundler options') {
+  if (
+    typeof value === 'function' ||
+    typeof value === 'symbol' ||
+    typeof value === 'bigint'
+  ) {
+    throw new Error(
+      `[one] ${keyPath} must be JSON-serializable to generate Babel/Metro config files. Move function-valued native linking/customization into an ejected config.`
+    )
+  }
+
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => assertSerializable(entry, `${keyPath}[${index}]`))
+    return
+  }
+
+  if (value && typeof value === 'object') {
+    for (const [key, entry] of Object.entries(value)) {
+      assertSerializable(entry, `${keyPath}.${key}`)
+    }
+  }
+}
+
+function serializeBundlerConfigOptions(options: OneBundlerConfigOptions): string {
+  const clean = stripUndefined(options) as OneBundlerConfigOptions
+  assertSerializable(clean)
+  return JSON.stringify(clean, null, 2)
+}
+
+export function getBundlerConfigOptionsFromOneOptions(
+  oneOptions: One.PluginOptions = {}
+): OneBundlerConfigOptions {
+  return stripUndefined({
+    routerRoot: getRouterRootFromOneOptions(oneOptions),
+    ignoredRouteFiles: oneOptions.router?.ignoredRouteFiles,
+    linking: oneOptions.router?.linking,
+    setupFile: oneOptions.setupFile,
+  }) as OneBundlerConfigOptions
+}
+
+export type GenerateBundlerConfigArgs = {
+  /** Project root. Defaults to `process.cwd()`. */
+  cwd?: string
+  /** loaded one plugin options from vite.config. */
+  oneOptions?: One.PluginOptions
+  /** Overwrite even when the file has been customized (marker removed). */
+  force?: boolean
+  /** Just verify state without writing — exits non-zero when out of sync. */
+  check?: boolean
+  /** Suppress logging. */
+  quiet?: boolean
+  /**
+   * Write files WITHOUT the `@one/generated` marker. The user owns the file
+   * after this; subsequent CI auto-gen runs will treat it as customized and
+   * skip it. used by `one metro-eject`.
+   */
+  eject?: boolean
+}
+
+export type FileResult = {
+  filePath: string
+  action: 'wrote' | 'kept' | 'skipped-customized' | 'skipped-other-format' | 'would-write' | 'would-overwrite'
+  reason?: string
+}
+
+export function generateBundlerConfig(args: GenerateBundlerConfigArgs = {}): {
+  results: FileResult[]
+  ok: boolean
+} {
+  const cwd = path.resolve(args.cwd ?? process.cwd())
+  const force = !!args.force
+  const check = !!args.check
+  const quiet = !!args.quiet
+
+  const log = (msg: string) => {
+    if (!quiet) console.info(msg)
+  }
+  const warn = (msg: string) => {
+    if (!quiet) console.warn(msg)
+  }
+
+  const results: FileResult[] = []
+
+  const eject = !!args.eject
+  const bundlerOptions = getBundlerConfigOptionsFromOneOptions(args.oneOptions)
+
+  for (const file of FILES) {
+    const filePath = path.join(cwd, file.name)
+    const targetContent = file.getContent({ eject, options: bundlerOptions })
+
+    // detect conflicting other-extension variants the user might be using
+    const conflict = file.conflicting.find((alt) => existsSync(path.join(cwd, alt)))
+    if (conflict && !existsSync(filePath)) {
+      results.push({
+        filePath: path.join(cwd, conflict),
+        action: 'skipped-other-format',
+        reason: `Found ${conflict}; not creating ${file.name}. To switch, delete ${conflict} and re-run with --force.`,
+      })
+      warn(
+        colors.yellow(
+          `[one] found ${conflict} — leaving it alone. Delete it and re-run with --force to switch to ${file.name}.`
+        )
+      )
+      continue
+    }
+
+    if (!existsSync(filePath)) {
+      if (check) {
+        results.push({ filePath, action: 'would-write' })
+        log(colors.yellow(`[one] missing: ${file.name}`))
+        continue
+      }
+      writeFileSync(filePath, targetContent)
+      results.push({ filePath, action: 'wrote' })
+      log(colors.green(`[one] wrote ${file.name}`))
+      continue
+    }
+
+    const existing = readFileSync(filePath, 'utf8')
+
+    if (existing === targetContent) {
+      results.push({ filePath, action: 'kept' })
+      log(colors.dim(`[one] up to date: ${file.name}`))
+      continue
+    }
+
+    const hasMarker = existing.includes(ONE_GENERATED_MARKER)
+
+    if (!hasMarker && !force) {
+      results.push({
+        filePath,
+        action: 'skipped-customized',
+        reason: `${file.name} has been customized (no @one marker). Re-add the marker comment or pass --force to overwrite.`,
+      })
+      warn(
+        colors.yellow(
+          `[one] ${file.name} appears customized — skipping. Pass --force to overwrite.`
+        )
+      )
+      continue
+    }
+
+    if (check) {
+      results.push({ filePath, action: 'would-overwrite' })
+      log(colors.yellow(`[one] out of date: ${file.name}`))
+      continue
+    }
+
+    writeFileSync(filePath, targetContent)
+    results.push({ filePath, action: 'wrote' })
+    log(colors.green(`[one] updated ${file.name}`))
+  }
+
+  // "ok" means the on-disk state is something we can live with — either we
+  // wrote what we wanted, the existing file is up to date, or the user has
+  // explicitly customized (their intent, not our problem).
+  // check mode is stricter: missing/stale files mean a regen is needed.
+  const acceptableAlways = new Set<FileResult['action']>([
+    'wrote',
+    'kept',
+    'skipped-other-format',
+    'skipped-customized',
+  ])
+  const acceptableInCheck = new Set<FileResult['action']>([
+    'kept',
+    'skipped-other-format',
+    'skipped-customized',
+  ])
+  const ok = (check ? acceptableInCheck : acceptableAlways).size
+    ? results.every((r) =>
+        (check ? acceptableInCheck : acceptableAlways).has(r.action)
+      )
+    : false
+
+  return { results, ok }
+}
+
+/**
+ * True when running on a CI/EAS worker. We only auto-generate bundler-config
+ * files in CI so they never appear in a developer's local working tree.
+ *
+ * Accepts any truthy value for `CI` / `EAS_BUILD` since providers vary:
+ * GitHub Actions sets `CI=true`, others use `CI=1`, EAS sets `EAS_BUILD=true`.
+ *
+ * Set `CI=1` (or `EAS_BUILD=true`) ahead of `eas update` if you need to
+ * publish from a local machine.
+ */
+export function isCiEnvironment(): boolean {
+  const truthy = (v: string | undefined) =>
+    !!v && v !== 'false' && v !== '0'
+  return truthy(process.env.EAS_BUILD) || truthy(process.env.CI)
+}
+
+/**
+ * Postinstall hook: when expo-updates is in deps AND we're running on
+ * a CI/EAS worker, ensure the bundler-config files exist so the
+ * subsequent `expo export` / EXUpdates Metro pass succeeds.
+ *
+ * No-op locally so the files never show up in a developer's working tree.
+ */
+export function maybeGenerateBundlerConfigOnInstall(
+  cwd: string = process.cwd(),
+  oneOptions?: One.PluginOptions
+): void {
+  if (!isCiEnvironment()) return
+
+  // detect expo-updates via the project's own resolver — same check used
+  // by the vxrn expo-plugin and one prebuild
+  try {
+    nodeModule
+      .createRequire(cwd + '/')
+      .resolve('expo-updates/package.json')
+  } catch {
+    return
+  }
+
+  generateBundlerConfig({ cwd, quiet: false, oneOptions })
+}

package/src/cli/patch.test.ts

@@ -0,0 +1,65 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { run } from './patch'
+
+const { patchMock, loadUserOneOptionsMock } = vi.hoisted(() => ({
+  patchMock: vi.fn(),
+  loadUserOneOptionsMock: vi.fn(),
+}))
+
+vi.mock('vxrn', () => ({
+  patch: patchMock,
+}))
+
+vi.mock('../vite/loadConfig', () => ({
+  loadUserOneOptions: loadUserOneOptionsMock,
+}))
+
+describe('one patch', () => {
+  beforeEach(() => {
+    patchMock.mockReset()
+    loadUserOneOptionsMock.mockReset()
+  })
+
+  it('applies built-in patches when a native-only app has no vite config', async () => {
+    loadUserOneOptionsMock.mockRejectedValueOnce(
+      new Error('No config config in /tmp/native-only-app. Is this the correct directory?')
+    )
+
+    await run({})
+
+    expect(patchMock).toHaveBeenCalledWith({
+      root: process.cwd(),
+      deps: undefined,
+      force: undefined,
+    })
+  })
+
+  it('passes configured user patches through to vxrn', async () => {
+    const patches = {
+      'example-package': {
+        version: '1',
+        'index.js': 'export default 1',
+      },
+    }
+    loadUserOneOptionsMock.mockResolvedValueOnce({
+      oneOptions: { patches },
+    })
+
+    await run({ force: true })
+
+    expect(patchMock).toHaveBeenCalledWith({
+      root: process.cwd(),
+      deps: patches,
+      force: true,
+    })
+  })
+
+  it('keeps failing when a vite config exists but does not load one', async () => {
+    loadUserOneOptionsMock.mockRejectedValueOnce(
+      new Error('One not loaded properly, is the one() plugin in your vite.config.ts?')
+    )
+
+    await expect(run({})).rejects.toThrow('One not loaded properly')
+    expect(patchMock).not.toHaveBeenCalled()
+  })
+})

package/src/cli/patch.ts

@@ -1,12 +1,40 @@
 import type { SimpleDepPatchObject, PatchOptions } from 'vxrn'
 import { loadUserOneOptions } from '../vite/loadConfig'
+import { maybeGenerateBundlerConfigOnInstall } from './generateBundlerConfig'
+
+function isMissingViteConfigError(error: unknown) {
+  return (
+    error instanceof Error &&
+    error.message.startsWith('No config config in ') &&
+    error.message.endsWith(' Is this the correct directory?')
+  )
+}
+
+async function loadUserOptions() {
+  try {
+    return await loadUserOneOptions('build')
+  } catch (error) {
+    if (isMissingViteConfigError(error)) {
+      return undefined
+    }
+    throw error
+  }
+}
 
 export async function run(args: { force?: boolean }) {
   process.env.IS_VXRN_CLI = 'true'
   const { patch } = await import('vxrn')
 
-  const options = await loadUserOneOptions('build')
-  const patches = options.oneOptions.patches as SimpleDepPatchObject | undefined
+  const options = await loadUserOptions()
+
+  // ensure babel.config.cjs + metro.config.cjs exist when a project uses
+  // expo-updates and we're on an eas/ci worker. the generated files capture
+  // the loaded one() router/setup options so standalone metro matches one.
+  if (options) {
+    maybeGenerateBundlerConfigOnInstall(process.cwd(), options.oneOptions)
+  }
+
+  const patches = options?.oneOptions.patches as SimpleDepPatchObject | undefined
 
   if (process.env.DEBUG) {
     console.info('User patches:', Object.keys(patches || {}))

package/src/cli.ts

@@ -33,6 +33,7 @@ const docsLinks = {
   patch: `${DOCS_BASE}/configuration`,
   'generate-routes': `${DOCS_BASE}/routing-typed-routes`,
   typegen: `${DOCS_BASE}/routing-typed-routes`,
+  'metro-eject': `${DOCS_BASE}/guides-ota-updates`,
 } as const
 
 function withDocsLink(description: string, command: keyof typeof docsLinks): string {
@@ -353,6 +354,35 @@ const typegen = defineCommand({
   },
 })
 
+const metroEject = defineCommand({
+  meta: {
+    name: 'metro-eject',
+    version: version,
+    description: withDocsLink(
+      'Write babel.config.cjs + metro.config.cjs so you can own them and customize freely',
+      'metro-eject'
+    ),
+  },
+  args: {
+    force: {
+      type: 'boolean',
+      description: 'Overwrite existing files',
+    },
+  },
+  async run({ args }) {
+    const { generateBundlerConfig } = await import('./cli/generateBundlerConfig')
+    const { loadUserOneOptions } = await import('./vite/loadConfig')
+    process.env.IS_VXRN_CLI = 'true'
+    const { oneOptions } = await loadUserOneOptions('build')
+    const { ok } = generateBundlerConfig({
+      force: !!args.force,
+      eject: true,
+      oneOptions,
+    })
+    if (!ok) process.exit(1)
+  },
+})
+
 const daemonCommand = defineCommand({
   meta: {
     name: 'daemon',
@@ -412,6 +442,7 @@ const subCommands = {
   'generate-routes': generateRoutes,
   typegen,
   daemon: daemonCommand,
+  'metro-eject': metroEject,
 }
 
 // workaround for having sub-commands but also positional arg for naming in the create flow

package/src/metro-config/buildOneMetroResolverOverrides.ts

@@ -0,0 +1,104 @@
+import module from 'node:module'
+import path from 'node:path'
+
+export type BuildOneMetroResolverOverridesOptions = {
+  projectRoot: string
+}
+
+export type MetroConfigLike = { resolver?: Record<string, any> } | undefined
+
+/**
+ * Build the Metro resolver overrides One needs for native bundles.
+ *
+ * Used by getViteMetroPluginOptions, which feeds these into the same
+ * getMetroConfigFromViteConfig pipeline both production native bundles and
+ * standalone Metro invocations (expo export, eas update) go through. The
+ * overrides handle One-specific concerns: server-only stripping, .css → empty,
+ * _middleware → empty, react-native-svg fix.
+ *
+ * Returns a function that takes Metro's default config and produces an
+ * overridden config. Callers compose any additional overrides on top.
+ */
+export function buildOneMetroResolverOverrides({
+  projectRoot,
+}: BuildOneMetroResolverOverridesOptions): <T extends MetroConfigLike>(
+  defaultConfig: T
+) => T {
+  const require = module.createRequire(projectRoot + '/')
+  const emptyPath = require.resolve('@vxrn/vite-plugin-metro/empty', {
+    paths: [projectRoot],
+  })
+
+  return <T extends MetroConfigLike>(defaultConfig: T): T => {
+    const resolver: Record<string, any> = {
+      ...defaultConfig?.resolver,
+      extraNodeModules: {
+        ...defaultConfig?.resolver?.extraNodeModules,
+      },
+      nodeModulesPaths: defaultConfig?.resolver?.nodeModulesPaths,
+      resolveRequest: (context: any, moduleName: string, platform: string) => {
+        if (moduleName.endsWith('.css')) {
+          return {
+            type: 'sourceFile',
+            filePath: emptyPath,
+          }
+        }
+
+        // On Vite side this is done by excludeAPIAndMiddlewareRoutesPlugin
+        if (/_middleware.tsx?$/.test(moduleName)) {
+          return {
+            type: 'sourceFile',
+            filePath: emptyPath,
+          }
+        }
+
+        // server-only files should never be in the native bundle.
+        // metro follows dynamic import chains (e.g. zero models →
+        // server effects → server packages) and tries to resolve
+        // everything, even though the code only runs on the server.
+        if (/\.server(\.[jt]sx?)?$/.test(moduleName)) {
+          return {
+            type: 'sourceFile',
+            filePath: emptyPath,
+          }
+        }
+
+        // react-native-svg's package.json has "react-native": "src/index.ts"
+        // which points to TS source that only type-exports Svg/Circle/Path etc.
+        // force resolution to the compiled JS which has proper named value exports.
+        if (moduleName === 'react-native-svg') {
+          const defaultResolveRequest =
+            defaultConfig?.resolver?.resolveRequest || context.resolveRequest
+          const res = defaultResolveRequest(context, moduleName, platform)
+          const svgSrcSuffix = `${path.sep}src${path.sep}index.ts`
+          if (res && 'filePath' in res && res.filePath.includes(svgSrcSuffix)) {
+            return {
+              ...res,
+              filePath: res.filePath.replace(
+                svgSrcSuffix,
+                `${path.sep}lib${path.sep}commonjs${path.sep}index.js`
+              ),
+            }
+          }
+          return res
+        }
+
+        const defaultResolveRequest =
+          defaultConfig?.resolver?.resolveRequest || context.resolveRequest
+        const res = defaultResolveRequest(context, moduleName, platform)
+
+        // catch .server files that were resolved by path
+        if (res && 'filePath' in res && /\.server\.[jt]sx?$/.test(res.filePath)) {
+          return { type: 'sourceFile', filePath: emptyPath }
+        }
+
+        return res
+      },
+    }
+
+    return {
+      ...(defaultConfig as any),
+      resolver,
+    } as T
+  }
+}

package/src/metro-config/getViteMetroPluginOptions.integration.test.ts

@@ -0,0 +1,75 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { getViteMetroPluginOptions } from './getViteMetroPluginOptions'
+
+/**
+ * the vite-driven metro path must always inject one's required babel plugins.
+ * a project babel.config can customize normal babel behavior, but it cannot be
+ * the source of truth for one's router/server-code transforms because ordinary
+ * react native configs do not know about them.
+ */
+describe('getViteMetroPluginOptions babel-config coexistence', () => {
+  let tmpDir: string
+
+  beforeAll(() => {
+    // place the fixture under the workspace root so Node can walk up to
+    // node_modules and resolve `one/metro-entry` + `@vxrn/vite-plugin-metro/empty`
+    const workspaceRoot = path.resolve(__dirname, '../../../../')
+    tmpDir = fs.mkdtempSync(path.join(workspaceRoot, '.tmp-one-vite-metro-test-'))
+    fs.writeFileSync(
+      path.join(tmpDir, 'tsconfig.json'),
+      JSON.stringify({ compilerOptions: { paths: {} } })
+    )
+    fs.writeFileSync(path.join(tmpDir, 'package.json'), JSON.stringify({ name: 'tmp' }))
+  })
+
+  afterAll(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  it('injects plugins when there is no user babel.config', () => {
+    const opts = getViteMetroPluginOptions({
+      projectRoot: tmpDir,
+      relativeRouterRoot: 'app',
+    })
+
+    expect(opts?.babelConfig?.plugins).toBeDefined()
+    expect(opts?.oneViteMetroBabelConfig).toBe(true)
+    // 5 One plugins (Vite path skips import-meta-env-plugin since it's
+    // injected separately via getMetroBabelConfigFromViteConfig)
+    expect(opts?.babelConfig?.plugins?.length).toBe(5)
+  })
+
+  it('still injects One plugins when the user has a babel.config.cjs', () => {
+    const cfgPath = path.join(tmpDir, 'babel.config.cjs')
+    fs.writeFileSync(cfgPath, "module.exports = require('one/babel-preset')\n")
+
+    try {
+      const opts = getViteMetroPluginOptions({
+        projectRoot: tmpDir,
+        relativeRouterRoot: 'app',
+      })
+
+      expect(opts?.babelConfig?.plugins?.length).toBe(5)
+    } finally {
+      fs.unlinkSync(cfgPath)
+    }
+  })
+
+  it('still injects One plugins when the user has a babel.config.js', () => {
+    const cfgPath = path.join(tmpDir, 'babel.config.js')
+    fs.writeFileSync(cfgPath, "module.exports = require('one/babel-preset')\n")
+
+    try {
+      const opts = getViteMetroPluginOptions({
+        projectRoot: tmpDir,
+        relativeRouterRoot: 'app',
+      })
+
+      expect(opts?.babelConfig?.plugins?.length).toBe(5)
+    } finally {
+      fs.unlinkSync(cfgPath)
+    }
+  })
+})