@comapeo/core 1.0.0 → 2.0.0

package/src/fastify-plugins/maps/index.js

@@ -1,173 +0,0 @@
-import fp from 'fastify-plugin'
-import { Type as T } from '@sinclair/typebox'
-import { fetch } from 'undici'
-
-import {
-  NotFoundError,
-  createStyleJsonResponseHeaders,
-  getFastifyServerAddress,
-} from '../utils.js'
-import { PLUGIN_NAME as MAPEO_STATIC_MAPS } from './static-maps.js'
-import { PLUGIN_NAME as MAPEO_OFFLINE_FALLBACK } from './offline-fallback-map.js'
-
-export const PLUGIN_NAME = 'mapeo-maps'
-export const DEFAULT_MAPBOX_STYLE_URL =
-  'https://api.mapbox.com/styles/v1/mapbox/outdoors-v12'
-
-const MAP_PROVIDER_API_KEY_QUERY_PARAM_BY_HOSTNAME = new Map([
-  // Mapbox expects `access_token`: https://docs.mapbox.com/api/maps/styles/
-  ['api.mapbox.com', 'access_token'],
-  // Protomaps expects `key` (no docs link yet)
-  ['api.protomaps.com', 'key'],
-  // MapTiler expects `key`: https://docs.maptiler.com/cloud/api/maps/
-  ['api.maptiler.com', 'key'],
-  // Stadia expects `api_key`: https://docs.stadiamaps.com/themes/
-  ['tiles.stadiamaps.com', 'api_key'],
-  // ArcGIS expects `token`: https://developers.arcgis.com/documentation/mapping-apis-and-services/security/api-keys/
-  ['basemapstyles-api.arcgis.com', 'token'],
-])
-
-export const plugin = fp(mapsPlugin, {
-  fastify: '4.x',
-  name: PLUGIN_NAME,
-  decorators: { fastify: ['mapeoStaticMaps', 'mapeoFallbackMap'] },
-  dependencies: [MAPEO_STATIC_MAPS, MAPEO_OFFLINE_FALLBACK],
-})
-
-/**
- * @typedef {object} MapsPluginOpts
- * @property {string} [prefix]
- * @property {string} [defaultOnlineStyleUrl]
- */
-
-/**
- * @typedef {object} MapsPluginContext
- * @property {() => Promise<string>} getStyleJsonUrl
- */
-
-/** @type {import('fastify').FastifyPluginAsync<MapsPluginOpts>} */
-async function mapsPlugin(fastify, opts) {
-  fastify.decorate('mapeoMaps', {
-    async getStyleJsonUrl() {
-      const base = await getFastifyServerAddress(fastify.server, {
-        timeout: 5000,
-      })
-
-      return new URL(`${opts.prefix || ''}/style.json`, base).href
-    },
-  })
-  fastify.register(routes, {
-    prefix: opts.prefix,
-    defaultOnlineStyleUrl: opts.defaultOnlineStyleUrl,
-  })
-}
-
-const GetStyleJsonQueryStringSchema = T.Object({
-  key: T.Optional(T.String()),
-})
-
-/** @type {import('fastify').FastifyPluginAsync<MapsPluginOpts, import('fastify').RawServerDefault, import('@fastify/type-provider-typebox').TypeBoxTypeProvider>} */
-async function routes(fastify, opts) {
-  const { defaultOnlineStyleUrl = DEFAULT_MAPBOX_STYLE_URL } = opts
-
-  fastify.get(
-    '/style.json',
-    { schema: { querystring: GetStyleJsonQueryStringSchema } },
-    async (req, rep) => {
-      const serverAddress = await getFastifyServerAddress(req.server.server)
-
-      // 1. Attempt to get "default" local static map's style.json
-      {
-        const styleId = 'default'
-
-        const results = await Promise.all([
-          fastify.mapeoStaticMaps.getStyleJsonStats(styleId),
-          fastify.mapeoStaticMaps.getResolvedStyleJson(styleId, serverAddress),
-        ]).catch(() => {
-          fastify.log.warn('Cannot read default static map')
-          return null
-        })
-
-        if (results) {
-          const [stats, styleJson] = results
-          rep.headers(createStyleJsonResponseHeaders(stats.mtime))
-          return styleJson
-        }
-      }
-
-      // 2. Attempt to get a default style.json from online source
-      {
-        const { key } = req.query
-
-        const upstreamUrlObj = new URL(defaultOnlineStyleUrl)
-        const { hostname } = upstreamUrlObj
-
-        if (key) {
-          const paramToUpsert =
-            MAP_PROVIDER_API_KEY_QUERY_PARAM_BY_HOSTNAME.get(hostname)
-
-          if (paramToUpsert) {
-            // Note that even if the search param of interest already exists in the url
-            // it is overwritten by the key provided in the request's search params
-            upstreamUrlObj.searchParams.set(paramToUpsert, key)
-          } else {
-            fastify.log.warn(
-              `Provided API key will not be applied to unrecognized provider: ${hostname}`
-            )
-          }
-        }
-
-        try {
-          const upstreamResponse = await fetch(upstreamUrlObj.href, {
-            signal: AbortSignal.timeout(30_000),
-          })
-
-          if (upstreamResponse.ok) {
-            // Set up headers to forward
-            for (const [name, value] of upstreamResponse.headers) {
-              // Only forward headers related to caching
-              // https://www.rfc-editor.org/rfc/rfc9111#name-field-definitions
-              // e.g. usage from map renderer: https://github.com/maplibre/maplibre-gl-js/blob/26a7a6c2c142ef2e26db89f5fdf2338769494902/src/util/ajax.ts#L205
-              if (
-                ['age', 'cache-control', 'expires'].includes(name.toLowerCase())
-              ) {
-                rep.header(name, value)
-              }
-            }
-            // Some upstream providers will not set the 'application/json' content-type header despite the body being JSON e.g. Protomaps
-            // TODO: Should we forward the upstream 'content-type' header?
-            // We kind of assume that a Style Spec-compatible JSON payload will always be used by a provider
-            // Technically, there could be cases where a provider doesn't use the Mapbox Style Spec and has their own format,
-            // which may be delivered as some other content type
-            rep.header('content-type', 'application/json; charset=utf-8')
-            return upstreamResponse.json()
-          } else {
-            fastify.log.warn(
-              `Upstream style.json request returned non-2xx status: ${upstreamResponse.status} ${upstreamResponse.statusText}`
-            )
-          }
-        } catch (err) {
-          fastify.log.warn('Failed to make upstream style.json request', err)
-        }
-      }
-
-      // 3. Provide offline fallback map's style.json
-      {
-        let results = null
-
-        try {
-          results = await Promise.all([
-            fastify.mapeoFallbackMap.getStyleJsonStats(),
-            fastify.mapeoFallbackMap.getResolvedStyleJson(serverAddress),
-          ])
-        } catch (err) {
-          throw new NotFoundError(`id = fallback, style.json`)
-        }
-
-        const [stats, styleJson] = results
-        rep.headers(createStyleJsonResponseHeaders(stats.mtime))
-        return styleJson
-      }
-    }
-  )
-}

package/src/fastify-plugins/maps/offline-fallback-map.js

@@ -1,114 +0,0 @@
-import path from 'path'
-import fs from 'fs/promises'
-import FastifyStatic from '@fastify/static'
-import fp from 'fastify-plugin'
-
-import {
-  NotFoundError,
-  createStyleJsonResponseHeaders,
-  getFastifyServerAddress,
-} from '../utils.js'
-
-export const PLUGIN_NAME = 'mapeo-static-maps'
-
-export const plugin = fp(offlineFallbackMapPlugin, {
-  fastify: '4.x',
-  name: PLUGIN_NAME,
-})
-
-/**
- * @typedef {object} OfflineFallbackMapPluginOpts
- * @property {string} [prefix]
- * @property {string} styleJsonPath
- * @property {string} sourcesDir
- */
-
-/**
- * @typedef {object} FallbackMapPluginDecorator
- * @property {(serverAddress: string) => Promise<any>} getResolvedStyleJson
- * @property {() => Promise<import('node:fs').Stats>} getStyleJsonStats
- */
-
-/** @type {import('fastify').FastifyPluginAsync<OfflineFallbackMapPluginOpts>} */
-async function offlineFallbackMapPlugin(fastify, opts) {
-  const { styleJsonPath, sourcesDir } = opts
-
-  fastify.decorate(
-    'mapeoFallbackMap',
-    /** @type {FallbackMapPluginDecorator} */
-    ({
-      async getResolvedStyleJson(serverAddress) {
-        const rawStyleJson = await fs.readFile(styleJsonPath, 'utf-8')
-        const styleJson = JSON.parse(rawStyleJson)
-
-        const sources = styleJson.sources || {}
-
-        const sourcesDirFiles = await fs.readdir(sourcesDir, {
-          withFileTypes: true,
-        })
-
-        for (const file of sourcesDirFiles) {
-          if (!file.isFile()) continue
-
-          if (file.name === 'style.json') continue
-
-          const extension = path.extname(file.name).toLowerCase()
-          if (!(extension === '.json' || extension === '.geojson')) continue
-
-          const sourceName = path.basename(file.name, extension) + '-source'
-
-          sources[sourceName] = {
-            type: 'geojson',
-            data: new URL(`${opts.prefix || ''}/${file.name}`, serverAddress)
-              .href,
-          }
-        }
-
-        styleJson.sources = sources
-
-        return styleJson
-      },
-      getStyleJsonStats() {
-        return fs.stat(styleJsonPath)
-      },
-    })
-  )
-
-  fastify.register(routes, {
-    prefix: opts.prefix,
-    styleJsonPath: opts.styleJsonPath,
-    sourcesDir: opts.sourcesDir,
-  })
-}
-
-/** @type {import('fastify').FastifyPluginAsync<OfflineFallbackMapPluginOpts, import('fastify').RawServerDefault, import('@fastify/type-provider-typebox').TypeBoxTypeProvider>} */
-async function routes(fastify, opts) {
-  const { sourcesDir } = opts
-
-  fastify.register(FastifyStatic, {
-    root: sourcesDir,
-    decorateReply: false,
-  })
-
-  fastify.get('/style.json', async (req, rep) => {
-    const serverAddress = await getFastifyServerAddress(req.server.server)
-
-    let stats, styleJson
-
-    try {
-      const results = await Promise.all([
-        fastify.mapeoFallbackMap.getStyleJsonStats(),
-        fastify.mapeoFallbackMap.getResolvedStyleJson(serverAddress),
-      ])
-
-      stats = results[0]
-      styleJson = results[1]
-    } catch (err) {
-      throw new NotFoundError(`id = fallback, style.json`)
-    }
-
-    rep.headers(createStyleJsonResponseHeaders(stats.mtime))
-
-    return styleJson
-  })
-}

package/src/fastify-plugins/maps/static-maps.js

@@ -1,271 +0,0 @@
-import path from 'path'
-import fs from 'fs/promises'
-import FastifyStatic from '@fastify/static'
-import fp from 'fastify-plugin'
-import { Type as T } from '@sinclair/typebox'
-import asar from '@electron/asar'
-import { Mime } from 'mime/lite'
-import standardTypes from 'mime/types/standard.js'
-
-import {
-  NotFoundError,
-  createStyleJsonResponseHeaders,
-  getFastifyServerAddress,
-} from '../utils.js'
-
-export const PLUGIN_NAME = 'mapeo-static-maps'
-
-export const plugin = fp(staticMapsPlugin, {
-  fastify: '4.x',
-  name: PLUGIN_NAME,
-})
-
-/**
- * @typedef {object} StaticMapsPluginOpts
- * @property {string} [prefix]
- * @property {string} staticRootDir
- */
-
-/**
- * @typedef {object} StaticMapsPluginDecorator
- * @property {(styleId: string, serverAddress: string) => Promise<string>} getResolvedStyleJson
- * @property {(styleId: string) => Promise<import('node:fs').Stats>} getStyleJsonStats
- */
-
-/** @type {import('fastify').FastifyPluginAsync<StaticMapsPluginOpts>} */
-async function staticMapsPlugin(fastify, opts) {
-  fastify.decorate('mapeoStaticMaps', {
-    async getResolvedStyleJson(styleId, serverAddress) {
-      const filePath = path.join(opts.staticRootDir, styleId, 'style.json')
-
-      const data = await fs.readFile(filePath, 'utf-8')
-
-      return data.replace(
-        /\{host\}/gm,
-        new URL(`${opts.prefix || ''}/${styleId}`, serverAddress).href
-      )
-    },
-    async getStyleJsonStats(styleId) {
-      const filePath = path.join(opts.staticRootDir, styleId, 'style.json')
-      const stats = await fs.stat(filePath)
-      return stats
-    },
-  })
-
-  fastify.register(routes, {
-    prefix: opts.prefix,
-    staticRootDir: opts.staticRootDir,
-  })
-}
-
-const GetStaticMapTileParamsSchema = T.Object({
-  styleId: T.String(),
-  tileId: T.String(),
-  z: T.Number(),
-  y: T.Number(),
-  x: T.Number(),
-  ext: T.Optional(T.String()),
-})
-
-const ListStaticMapsReplySchema = T.Array(
-  T.Object({
-    id: T.String(),
-    name: T.Union([T.String(), T.Null()]),
-    styleUrl: T.String(),
-  })
-)
-
-const GetStyleJsonParamsSchema = T.Object({
-  styleId: T.String(),
-})
-
-/** @type {import('fastify').FastifyPluginAsync<StaticMapsPluginOpts, import('fastify').RawServerDefault, import('@fastify/type-provider-typebox').TypeBoxTypeProvider>} */
-async function routes(fastify, opts) {
-  const { staticRootDir } = opts
-
-  /**
-   * @param {import('fastify').FastifyRequest<{Params: import('@sinclair/typebox').Static<typeof GetStaticMapTileParamsSchema>}>} req
-   * @param {import('fastify').FastifyReply} rep
-   */
-  async function handleStyleTileGet(req, rep) {
-    const result = getStyleTileInfo(staticRootDir, req.params)
-
-    if (!result) {
-      const { tileId, z, x, y, ext } = req.params
-      throw new NotFoundError(
-        `Tileset id = ${tileId}, ext=${ext}, [${z}, ${x}, ${y}]`
-      )
-    }
-
-    const { data, mimeType } = result
-
-    if (mimeType) {
-      rep.header('Content-Type', mimeType)
-    }
-
-    rep.send(data)
-  }
-
-  // Serve static files
-  fastify.register(FastifyStatic, {
-    root: staticRootDir,
-    setHeaders: (res, path) => {
-      if (path.toLowerCase().endsWith('.pbf')) {
-        res.setHeader('Content-Type', 'application/x-protobuf')
-      }
-    },
-  })
-
-  /// List static maps
-  fastify.get(
-    '/',
-    { schema: { response: { 200: ListStaticMapsReplySchema } } },
-    async (req) => {
-      const styleDirFiles = await fs.readdir(staticRootDir)
-
-      const serverAddress = await getFastifyServerAddress(req.server.server)
-
-      const result = (
-        await Promise.all(
-          styleDirFiles.map(async (filename) => {
-            const stat = await fs.stat(path.join(staticRootDir, filename))
-            if (!stat.isDirectory()) return null
-
-            let styleJson
-
-            try {
-              const styleJsonContent = await fs.readFile(
-                path.join(staticRootDir, filename, 'style.json'),
-                'utf-8'
-              )
-
-              styleJson = JSON.parse(styleJsonContent)
-            } catch (err) {
-              return null
-            }
-
-            return {
-              id: filename,
-              name: typeof styleJson.name === 'string' ? styleJson.name : null,
-              styleUrl: new URL(
-                `${req.server.prefix || ''}/${filename}/style.json`,
-                serverAddress
-              ).href,
-            }
-          })
-        )
-      ).filter(
-        /**
-         * @template {import('@sinclair/typebox').Static<typeof ListStaticMapsReplySchema>[number] | null} V
-         * @param {V} v
-         * @returns {v is NonNullable<V>}
-         */
-        (v) => v !== null
-      )
-
-      return result
-    }
-  )
-
-  /// Get a map's style.json
-  fastify.get(
-    `/:styleId/style.json`,
-    { schema: { params: GetStyleJsonParamsSchema } },
-    async (req, rep) => {
-      const { styleId } = req.params
-
-      const serverAddress = await getFastifyServerAddress(req.server.server)
-
-      let stats, styleJson
-
-      try {
-        const results = await Promise.all([
-          fastify.mapeoStaticMaps.getStyleJsonStats(styleId),
-          fastify.mapeoStaticMaps.getResolvedStyleJson(styleId, serverAddress),
-        ])
-
-        stats = results[0]
-        styleJson = results[1]
-      } catch (err) {
-        throw new NotFoundError(`id = ${styleId}, style.json`)
-      }
-
-      rep.headers(createStyleJsonResponseHeaders(stats.mtime))
-
-      return styleJson
-    }
-  )
-
-  // Get a tile (extension specified)
-  fastify.get(
-    `/:styleId/tiles/:tileId/:z/:x/:y.:ext`,
-    { schema: { params: GetStaticMapTileParamsSchema } },
-    handleStyleTileGet
-  )
-  // Get a tile (extension not specified)
-  fastify.get(
-    `/:styleId/tiles/:tileId/:z/:x/:y`,
-    { schema: { params: GetStaticMapTileParamsSchema } },
-    handleStyleTileGet
-  )
-}
-
-/**
- * @param {string} archive
- * @param {string} filename
- */
-function extractAsarFile(archive, filename) {
-  try {
-    return asar.extractFile(archive, filename)
-  } catch (err) {
-    return undefined
-  }
-}
-
-const mime = new Mime(standardTypes, { 'application/x-protobuf': ['pbf'] })
-
-/**
- * @param {string} baseDirectory
- * @param {import('@sinclair/typebox').Static<typeof GetStaticMapTileParamsSchema>} params
- * @returns {null | { data: Buffer, mimeType: string | null }}
- */
-function getStyleTileInfo(baseDirectory, params) {
-  const { styleId, tileId, z, x, y } = params
-  let { ext } = params
-
-  // TODO: If necessary, need to flip the y value first if the TileJSON source is TMS scheme
-  // Doing this will depend on if we decide that the asar directory structure should only follow XYZ or if it should align with corresponding tilejson spec
-
-  const fileBasename = path.join(z.toString(), x.toString(), y.toString())
-  const asarPath = path.join(baseDirectory, styleId, 'tiles', tileId + '.asar')
-
-  /** @type {Buffer | undefined} */
-  let data
-
-  if (ext) {
-    data = extractAsarFile(asarPath, fileBasename + '.' + ext)
-  } else {
-    // Try common extensions
-    const extensions = ['png', 'jpg', 'jpeg']
-
-    for (const e of extensions) {
-      data = extractAsarFile(asarPath, fileBasename + '.' + e)
-
-      // Match found, use the corresponding extension moving forward
-      if (data) {
-        ext = e
-        break
-      }
-    }
-  }
-
-  // extension check isn't fully necessary since the buffer will only exist if the extension exists
-  // but useful to check for types reasons
-  if (!data || !ext) {
-    return null
-  }
-
-  const mimeType = mime.getType(ext)
-
-  return { data, mimeType }
-}