@comapeo/core 1.0.0

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

@@ -0,0 +1,271 @@
+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 }
+}

package/src/fastify-plugins/utils.js

@@ -0,0 +1,52 @@
+import { once } from 'node:events'
+import createError from '@fastify/error'
+
+export const NotFoundError = createError(
+  'FST_RESOURCE_NOT_FOUND',
+  'Resource `%s` not found',
+  404
+)
+
+/**
+ * @param {import('node:http').Server} server
+ * @param {{ timeout?: number }} [options]
+ * @returns {Promise<string>}
+ */
+export async function getFastifyServerAddress(server, { timeout } = {}) {
+  const address = server.address()
+
+  if (!address) {
+    await once(server, 'listening', {
+      signal: timeout ? AbortSignal.timeout(timeout) : undefined,
+    })
+    return getFastifyServerAddress(server)
+  }
+
+  if (typeof address === 'string') {
+    return address
+  }
+
+  // Full address construction for non unix-socket address
+  // https://github.com/fastify/fastify/blob/7aa802ed224b91ca559edec469a6b903e89a7f88/lib/server.js#L413
+  let addr = ''
+  if (address.address.indexOf(':') === -1) {
+    addr += address.address + ':' + address.port
+  } else {
+    addr += '[' + address.address + ']:' + address.port
+  }
+
+  return 'http://' + addr
+}
+
+/**
+ * @param {Readonly<Date>} lastModified
+ */
+export function createStyleJsonResponseHeaders(lastModified) {
+  return {
+    'Cache-Control': 'max-age=' + 5 * 60, // 5 minutes
+    'Access-Control-Allow-Headers':
+      'Authorization, Content-Type, If-Match, If-Modified-Since, If-None-Match, If-Unmodified-Since',
+    'Access-Control-Allow-Origin': '*',
+    'Last-Modified': lastModified.toUTCString(),
+  }
+}

package/src/generated/README.md

@@ -0,0 +1,3 @@
+## Generated from Protobuf schema
+
+These files are generated by the protobuf schema in [`../proto`](../proto) using the script in [`../scripts/build-messages.js`](../scripts/build-messages.js)

package/src/generated/extensions.d.ts

@@ -0,0 +1,44 @@
+import _m0 from "protobufjs/minimal.js";
+export interface ProjectExtension {
+    authCoreKeys: Buffer[];
+}
+export interface HaveExtension {
+    discoveryKey: Buffer;
+    start: number;
+    encodedBitfield: Buffer;
+    namespace: HaveExtension_Namespace;
+}
+export declare const HaveExtension_Namespace: {
+    readonly auth: "auth";
+    readonly config: "config";
+    readonly data: "data";
+    readonly blobIndex: "blobIndex";
+    readonly blob: "blob";
+    readonly UNRECOGNIZED: "UNRECOGNIZED";
+};
+export type HaveExtension_Namespace = typeof HaveExtension_Namespace[keyof typeof HaveExtension_Namespace];
+export declare function haveExtension_NamespaceFromJSON(object: any): HaveExtension_Namespace;
+export declare function haveExtension_NamespaceToNumber(object: HaveExtension_Namespace): number;
+export declare const ProjectExtension: {
+    encode(message: ProjectExtension, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): ProjectExtension;
+    create<I extends Exact<DeepPartial<ProjectExtension>, I>>(base?: I): ProjectExtension;
+    fromPartial<I extends Exact<DeepPartial<ProjectExtension>, I>>(object: I): ProjectExtension;
+};
+export declare const HaveExtension: {
+    encode(message: HaveExtension, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): HaveExtension;
+    create<I extends Exact<DeepPartial<HaveExtension>, I>>(base?: I): HaveExtension;
+    fromPartial<I extends Exact<DeepPartial<HaveExtension>, I>>(object: I): HaveExtension;
+};
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export {};

package/src/generated/extensions.js

@@ -0,0 +1,196 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal.js";
+export var HaveExtension_Namespace = {
+    auth: "auth",
+    config: "config",
+    data: "data",
+    blobIndex: "blobIndex",
+    blob: "blob",
+    UNRECOGNIZED: "UNRECOGNIZED",
+};
+export function haveExtension_NamespaceFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "auth":
+            return HaveExtension_Namespace.auth;
+        case 1:
+        case "config":
+            return HaveExtension_Namespace.config;
+        case 2:
+        case "data":
+            return HaveExtension_Namespace.data;
+        case 3:
+        case "blobIndex":
+            return HaveExtension_Namespace.blobIndex;
+        case 4:
+        case "blob":
+            return HaveExtension_Namespace.blob;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return HaveExtension_Namespace.UNRECOGNIZED;
+    }
+}
+export function haveExtension_NamespaceToNumber(object) {
+    switch (object) {
+        case HaveExtension_Namespace.auth:
+            return 0;
+        case HaveExtension_Namespace.config:
+            return 1;
+        case HaveExtension_Namespace.data:
+            return 2;
+        case HaveExtension_Namespace.blobIndex:
+            return 3;
+        case HaveExtension_Namespace.blob:
+            return 4;
+        case HaveExtension_Namespace.UNRECOGNIZED:
+        default:
+            return -1;
+    }
+}
+function createBaseProjectExtension() {
+    return { authCoreKeys: [] };
+}
+export var ProjectExtension = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        for (var _i = 0, _a = message.authCoreKeys; _i < _a.length; _i++) {
+            var v = _a[_i];
+            writer.uint32(10).bytes(v);
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseProjectExtension();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.authCoreKeys.push(reader.bytes());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    create: function (base) {
+        return ProjectExtension.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial: function (object) {
+        var _a;
+        var message = createBaseProjectExtension();
+        message.authCoreKeys = ((_a = object.authCoreKeys) === null || _a === void 0 ? void 0 : _a.map(function (e) { return e; })) || [];
+        return message;
+    },
+};
+function createBaseHaveExtension() {
+    return {
+        discoveryKey: Buffer.alloc(0),
+        start: 0,
+        encodedBitfield: Buffer.alloc(0),
+        namespace: HaveExtension_Namespace.auth,
+    };
+}
+export var HaveExtension = {
+    encode: function (message, writer) {
+        if (writer === void 0) { writer = _m0.Writer.create(); }
+        if (message.discoveryKey.length !== 0) {
+            writer.uint32(10).bytes(message.discoveryKey);
+        }
+        if (message.start !== 0) {
+            writer.uint32(16).uint64(message.start);
+        }
+        if (message.encodedBitfield.length !== 0) {
+            writer.uint32(26).bytes(message.encodedBitfield);
+        }
+        if (message.namespace !== HaveExtension_Namespace.auth) {
+            writer.uint32(32).int32(haveExtension_NamespaceToNumber(message.namespace));
+        }
+        return writer;
+    },
+    decode: function (input, length) {
+        var reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        var end = length === undefined ? reader.len : reader.pos + length;
+        var message = createBaseHaveExtension();
+        while (reader.pos < end) {
+            var tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.discoveryKey = reader.bytes();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.start = longToNumber(reader.uint64());
+                    continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.encodedBitfield = reader.bytes();
+                    continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.namespace = haveExtension_NamespaceFromJSON(reader.int32());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    create: function (base) {
+        return HaveExtension.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial: function (object) {
+        var _a, _b, _c, _d;
+        var message = createBaseHaveExtension();
+        message.discoveryKey = (_a = object.discoveryKey) !== null && _a !== void 0 ? _a : Buffer.alloc(0);
+        message.start = (_b = object.start) !== null && _b !== void 0 ? _b : 0;
+        message.encodedBitfield = (_c = object.encodedBitfield) !== null && _c !== void 0 ? _c : Buffer.alloc(0);
+        message.namespace = (_d = object.namespace) !== null && _d !== void 0 ? _d : HaveExtension_Namespace.auth;
+        return message;
+    },
+};
+var tsProtoGlobalThis = (function () {
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    if (typeof self !== "undefined") {
+        return self;
+    }
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    throw "Unable to locate global object";
+})();
+function longToNumber(long) {
+    if (long.gt(Number.MAX_SAFE_INTEGER)) {
+        throw new tsProtoGlobalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    return long.toNumber();
+}
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
+}