@remix-run/assets 0.0.0 → 0.2.0

package/src/lib/styles/resolve.ts

@@ -0,0 +1,316 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+import {
+  createAssetServerCompilationError,
+  isAssetServerCompilationError,
+} from '../compilation-error.ts'
+import { normalizeFilePath } from '../paths.ts'
+import type { AssetServerCompilationError } from '../compilation-error.ts'
+import type { ModuleRecord, ModuleTracking } from '../module-store.ts'
+import type { CompiledRoutes } from '../routes.ts'
+import type { EmittedStyle } from './emit.ts'
+import type { TransformedStyle } from './transform.ts'
+
+type StyleRecord = ModuleRecord<TransformedStyle, ResolvedStyle, EmittedStyle>
+
+type ResolvedDependency =
+  | {
+      kind: 'external'
+      placeholder: string
+      replacement: string
+    }
+  | {
+      depPath: string
+      kind: 'local'
+      placeholder: string
+      suffix: string
+    }
+
+export type ResolvedStyle = {
+  dependencies: ResolvedDependency[]
+  deps: string[]
+  fingerprint: string | null
+  identityPath: string
+  rawCode: string
+  resolvedPath: string
+  sourceMap: string | null
+  stableUrlPathname: string
+  trackedFiles: string[]
+}
+
+export type ResolveArgs = {
+  isAllowed(absolutePath: string): boolean
+  isWatchIgnored(filePath: string): boolean
+  routes: CompiledRoutes
+}
+
+type ResolveResult = {
+  tracking: ModuleTracking
+} & (
+  | {
+      ok: true
+      value: ResolvedStyle
+    }
+  | {
+      error: AssetServerCompilationError
+      ok: false
+    }
+)
+
+export async function resolveStyle(
+  record: StyleRecord,
+  transformed: TransformedStyle,
+  args: ResolveArgs,
+): Promise<ResolveResult> {
+  let trackedFiles = new Set(transformed.trackedFiles)
+  let dependencies: ResolvedDependency[] = []
+  let deps = new Set<string>()
+
+  for (let unresolved of transformed.unresolvedDependencies) {
+    let trackedFile =
+      unresolved.type === 'import'
+        ? getTrackedImportFilePath(unresolved.url, transformed.resolvedPath)
+        : null
+    if (trackedFile && !args.isWatchIgnored(trackedFile)) {
+      trackedFiles.add(trackedFile)
+    }
+
+    try {
+      let resolved =
+        unresolved.type === 'import'
+          ? resolveImportDependency(
+              unresolved.url,
+              transformed.resolvedPath,
+              unresolved.placeholder,
+              args,
+            )
+          : resolveUrlDependency(unresolved.url, unresolved.placeholder)
+
+      dependencies.push(resolved)
+
+      if (resolved.kind === 'local') {
+        if (!args.isWatchIgnored(resolved.depPath)) {
+          trackedFiles.add(resolved.depPath)
+        }
+        deps.add(resolved.depPath)
+      }
+    } catch (error) {
+      return failResolve(error, trackedFiles, transformed.resolvedPath)
+    }
+  }
+
+  return {
+    ok: true,
+    tracking: {
+      trackedFiles: [...trackedFiles],
+    },
+    value: {
+      dependencies,
+      deps: [...deps],
+      fingerprint: transformed.fingerprint,
+      identityPath: record.identityPath,
+      rawCode: transformed.rawCode,
+      resolvedPath: transformed.resolvedPath,
+      sourceMap: transformed.sourceMap,
+      stableUrlPathname: transformed.stableUrlPathname,
+      trackedFiles: [...trackedFiles],
+    },
+  }
+}
+
+export function resolveServedStyleOrThrow(
+  filePath: string,
+  args: ResolveArgs,
+): {
+  identityPath: string
+  stableUrlPathname: string
+} {
+  let identityPath = resolveExistingFilePath(filePath)
+  if (!identityPath) {
+    throw createAssetServerCompilationError(`File not found: ${filePath}`, {
+      code: 'FILE_NOT_FOUND',
+    })
+  }
+
+  if (!isStyleFilePath(identityPath)) {
+    throw createAssetServerCompilationError(`File not found: ${identityPath}`, {
+      code: 'FILE_NOT_FOUND',
+    })
+  }
+
+  if (!args.isAllowed(identityPath)) {
+    throw createAssetServerCompilationError(`File is not allowed: ${identityPath}`, {
+      code: 'FILE_NOT_ALLOWED',
+    })
+  }
+
+  let stableUrlPathname = args.routes.toUrlPathname(identityPath)
+  if (!stableUrlPathname) {
+    throw createAssetServerCompilationError(
+      `File ${identityPath} is outside all configured fileMap entries.`,
+      {
+        code: 'FILE_OUTSIDE_FILE_MAP',
+      },
+    )
+  }
+
+  return { identityPath, stableUrlPathname }
+}
+
+function resolveImportDependency(
+  url: string,
+  importerPath: string,
+  placeholder: string,
+  args: ResolveArgs,
+): ResolvedDependency {
+  if (isExternalUrl(url)) {
+    return {
+      kind: 'external',
+      placeholder,
+      replacement: url,
+    }
+  }
+
+  let { pathname, suffix } = splitUrlSuffix(url)
+  if (pathname.length === 0 || pathname === '#') {
+    return {
+      kind: 'external',
+      placeholder,
+      replacement: url,
+    }
+  }
+
+  if (pathname.startsWith('/')) {
+    return {
+      kind: 'external',
+      placeholder,
+      replacement: url,
+    }
+  }
+
+  let resolvedFilePath = normalizeFilePath(path.resolve(path.dirname(importerPath), pathname))
+  let identityPath = resolveExistingFilePath(resolvedFilePath)
+  if (!identityPath || !isStyleFilePath(identityPath)) {
+    throw createAssetServerCompilationError(
+      `Failed to resolve import "${url}" in ${importerPath}.`,
+      {
+        code: 'IMPORT_RESOLUTION_FAILED',
+      },
+    )
+  }
+
+  if (!args.isAllowed(identityPath)) {
+    throw createAssetServerCompilationError(
+      `Import "${url}" in ${importerPath}, resolved to "${identityPath}", is not allowed by the asset server allow/deny configuration. ` +
+        `Add a matching allow rule for this file path, remove a conflicting deny rule for this file path, or mark this import as external.`,
+      {
+        code: 'IMPORT_NOT_ALLOWED',
+      },
+    )
+  }
+
+  if (!args.routes.toUrlPathname(identityPath)) {
+    throw createAssetServerCompilationError(
+      `Import "${url}" in ${importerPath}, resolved to "${identityPath}", is outside all configured fileMap entries. ` +
+        `Add a matching fileMap entry for this file path, or mark this import as external.`,
+      {
+        code: 'IMPORT_OUTSIDE_FILE_MAP',
+      },
+    )
+  }
+
+  return {
+    depPath: identityPath,
+    kind: 'local',
+    placeholder,
+    suffix,
+  }
+}
+
+function resolveUrlDependency(url: string, placeholder: string): ResolvedDependency {
+  return {
+    kind: 'external',
+    placeholder,
+    replacement: url,
+  }
+}
+
+function resolveExistingFilePath(filePath: string): string | null {
+  try {
+    return normalizeFilePath(fs.realpathSync(filePath))
+  } catch (error) {
+    if (isNoEntityError(error)) return null
+    throw error
+  }
+}
+
+function splitUrlSuffix(url: string): {
+  pathname: string
+  suffix: string
+} {
+  let queryIndex = url.indexOf('?')
+  let hashIndex = url.indexOf('#')
+  let endIndex = [queryIndex, hashIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0]
+
+  if (endIndex == null) {
+    return {
+      pathname: url,
+      suffix: '',
+    }
+  }
+
+  return {
+    pathname: url.slice(0, endIndex),
+    suffix: url.slice(endIndex),
+  }
+}
+
+function getTrackedImportFilePath(specifier: string, importerPath: string): string | null {
+  let { pathname } = splitUrlSuffix(specifier)
+  if (pathname.startsWith('./') || pathname.startsWith('../')) {
+    return normalizeFilePath(path.resolve(path.dirname(importerPath), pathname))
+  }
+
+  return null
+}
+
+function isStyleFilePath(filePath: string): boolean {
+  return path.extname(filePath).toLowerCase() === '.css'
+}
+
+function isExternalUrl(url: string): boolean {
+  return url.startsWith('#') || url.startsWith('//') || /^[A-Za-z][A-Za-z\d+.-]*:/.test(url)
+}
+
+function isNoEntityError(error: unknown): error is NodeJS.ErrnoException & { code: 'ENOENT' } {
+  return (
+    error instanceof Error && 'code' in error && (error as NodeJS.ErrnoException).code === 'ENOENT'
+  )
+}
+
+function toResolveError(error: unknown, importerPath: string): AssetServerCompilationError {
+  if (isAssetServerCompilationError(error)) return error
+
+  return createAssetServerCompilationError(
+    `Failed to resolve imports in ${importerPath}. ${error instanceof Error ? error.message : String(error)}`,
+    {
+      cause: error,
+      code: 'IMPORT_RESOLUTION_FAILED',
+    },
+  )
+}
+
+function failResolve(
+  error: unknown,
+  trackedFiles: ReadonlySet<string>,
+  importerPath: string,
+): ResolveResult {
+  return {
+    ok: false,
+    error: toResolveError(error, importerPath),
+    tracking: {
+      trackedFiles: [...trackedFiles],
+    },
+  }
+}

package/src/lib/styles/transform.ts

@@ -0,0 +1,226 @@
+import * as fs from 'node:fs/promises'
+import { transform } from 'lightningcss'
+
+import {
+  createAssetServerCompilationError,
+  isAssetServerCompilationError,
+} from '../compilation-error.ts'
+import { generateFingerprint } from '../fingerprint.ts'
+import type { ModuleTracking } from '../module-store.ts'
+import { rewriteSourceMapSources, stringifySourceMap } from '../source-maps.ts'
+import type { AssetServerCompilationError } from '../compilation-error.ts'
+import type { CompiledRoutes } from '../routes.ts'
+import type { ResolvedStyleTarget } from '../target.ts'
+
+type TransformedStyleDependency =
+  | {
+      placeholder: string
+      type: 'import'
+      url: string
+    }
+  | {
+      placeholder: string
+      type: 'url'
+      url: string
+    }
+
+export type TransformedStyle = {
+  fingerprint: string | null
+  identityPath: string
+  rawCode: string
+  resolvedPath: string
+  sourceMap: string | null
+  stableUrlPathname: string
+  trackedFiles: string[]
+  unresolvedDependencies: TransformedStyleDependency[]
+}
+
+type TransformResult = {
+  tracking: ModuleTracking
+} & (
+  | {
+      ok: true
+      value: TransformedStyle
+    }
+  | {
+      error: AssetServerCompilationError
+      ok: false
+    }
+)
+
+export type TransformArgs = {
+  buildId: string | null
+  isWatchIgnored(filePath: string): boolean
+  minify: boolean
+  routes: CompiledRoutes
+  sourceMaps: 'external' | 'inline' | null
+  sourceMapSourcePaths: 'absolute' | 'url'
+  targets: ResolvedStyleTarget | null
+}
+
+type TransformRecord = {
+  identityPath: string
+}
+
+export async function transformStyle(
+  record: TransformRecord,
+  args: TransformArgs,
+): Promise<TransformResult> {
+  let resolvedPath = record.identityPath
+  let trackedFiles = args.isWatchIgnored(resolvedPath) ? [] : [resolvedPath]
+  let rawBytes: Uint8Array
+
+  try {
+    rawBytes = new Uint8Array(await fs.readFile(resolvedPath))
+  } catch (error) {
+    if (isNoEntityError(error)) {
+      return {
+        ok: false,
+        error: createAssetServerCompilationError(`File not found: ${resolvedPath}`, {
+          cause: error,
+          code: 'FILE_NOT_FOUND',
+        }),
+        tracking: {
+          trackedFiles,
+        },
+      }
+    }
+
+    return {
+      ok: false,
+      error: toTransformFailedError(error, resolvedPath),
+      tracking: {
+        trackedFiles,
+      },
+    }
+  }
+
+  try {
+    let stableUrlPathname = args.routes.toUrlPathname(record.identityPath)
+    if (!stableUrlPathname) {
+      throw createAssetServerCompilationError(
+        `File ${record.identityPath} is outside all configured fileMap entries.`,
+        {
+          code: 'FILE_OUTSIDE_FILE_MAP',
+        },
+      )
+    }
+
+    let transformResult = runLightningTransform(resolvedPath, rawBytes, {
+      minify: args.minify,
+      sourceMap: args.sourceMaps != null,
+      targets: args.targets,
+    })
+    let sourceText = Buffer.from(rawBytes).toString('utf8')
+    let sourceMap = stringifySourceMap(transformResult.map)
+    sourceMap = sourceMap
+      ? rewriteSourceMapSources(
+          sourceMap,
+          resolvedPath,
+          stableUrlPathname,
+          args.sourceMapSourcePaths,
+          sourceText,
+        )
+      : null
+
+    let unresolvedDependencies: TransformedStyleDependency[] = []
+    for (let dependency of transformResult.dependencies ?? []) {
+      if (dependency.type === 'import') {
+        unresolvedDependencies.push({
+          placeholder: dependency.placeholder,
+          type: 'import',
+          url: dependency.url,
+        })
+        continue
+      }
+
+      if (dependency.type === 'url') {
+        unresolvedDependencies.push({
+          placeholder: dependency.placeholder,
+          type: 'url',
+          url: dependency.url,
+        })
+      }
+    }
+
+    return {
+      ok: true,
+      tracking: {
+        trackedFiles,
+      },
+      value: {
+        fingerprint:
+          args.buildId === null
+            ? null
+            : await generateFingerprint({
+                buildId: args.buildId,
+                content: sourceText,
+              }),
+        identityPath: record.identityPath,
+        rawCode: Buffer.from(transformResult.code).toString('utf8'),
+        resolvedPath,
+        sourceMap,
+        stableUrlPathname,
+        trackedFiles,
+        unresolvedDependencies,
+      },
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      error: toTransformFailedError(error, resolvedPath),
+      tracking: {
+        trackedFiles,
+      },
+    }
+  }
+}
+
+function runLightningTransform(
+  identityPath: string,
+  code: Uint8Array,
+  options: {
+    minify: boolean
+    sourceMap: boolean
+    targets: ResolvedStyleTarget | null
+  },
+) {
+  try {
+    return transform({
+      analyzeDependencies: {
+        preserveImports: true,
+      },
+      code,
+      filename: identityPath,
+      minify: options.minify,
+      sourceMap: options.sourceMap,
+      targets: options.targets ?? undefined,
+    })
+  } catch (error) {
+    throw createAssetServerCompilationError(
+      `Failed to transform style ${identityPath}. ${error instanceof Error ? error.message : String(error)}`,
+      {
+        cause: error,
+        code: 'TRANSFORM_FAILED',
+      },
+    )
+  }
+}
+
+function toTransformFailedError(error: unknown, resolvedPath: string): AssetServerCompilationError {
+  if (isAssetServerCompilationError(error)) return error
+
+  return createAssetServerCompilationError(
+    `Failed to transform style ${resolvedPath}. ${error instanceof Error ? error.message : String(error)}`,
+    {
+      cause: error,
+      code: 'TRANSFORM_FAILED',
+    },
+  )
+}
+
+function isNoEntityError(error: unknown): error is NodeJS.ErrnoException & { code: 'ENOENT' } {
+  return (
+    error instanceof Error && 'code' in error && (error as NodeJS.ErrnoException).code === 'ENOENT'
+  )
+}