@comapeo/core 2.3.0 → 2.3.1

package/dist/core-manager/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core-manager/index.js"],"names":[],"mappings":"AAwBA,kDAAqE;AAErE,kDAAkD;AAClD,8EAA8E;AAC9E;;;;;GAKG;AAEH;;GAEG;AACH;IAkBE,kFAEC;IAED;;;;;;;;;;OAUG;IACH,8GATG;QAA4E,EAAE,EAAtE,OAAO,4BAA4B,EAAE,qBAAqB;QACd,UAAU,EAAtD,2CAAkC;QAClB,UAAU,EAA1B,MAAM;QACW,gBAAgB;QACY,cAAc;QACb,OAAO,EAArD,OAAO,WAAW,EAAE,gBAAgB;QAClB,YAAY;QACb,MAAM;KAAC,EA0HlC;IAED,uBAEC;IAED,wBAEC;IAED,oCAEC;IAED;;;;OAIG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,yBAFW,SAAS,cAInB;IAED;;;;OAIG;IACH,oBAFW,SAAS,gBAInB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,IAAI,GAAG,SAAS,CAK5B;IAED;;;;;OAKG;IACH,oCAHW,MAAM,GACJ,UAAU,GAAG,SAAS,CAOlC;IAED;;;OAGG;IACH,uBAQC;IAED;;;;;;OAMG;IACH,aAJW,MAAM,aACN,SAAS,GACP,UAAU,CAItB;IAiJD;;;OAGG;IACH,gCAHW,UAAU,QACV,aAAa,QAIvB;IAgDD;;;OAGG;IACH,4BAHW,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAhCD;;;;;;;;OAQG;IACH,gCAFW,UAAU,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,qBAK/C;;CAqBF;mBAvda,UAAU,QAAQ,EAAE,MAAM,CAAC;yBAC3B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,SAAS,CAAA;CAAE;;gBAGjD,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI;iBAChC,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,KAAK,IAAI;4BACtH,CAAC,UAAU,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI;;;kBAqdvD,MAAM;WACN,MAAM;cACN,WAAW;eACX,SAAS;;6BAxfM,oBAAoB;+BAoB4B,aAAa;gCAAb,aAAa;mCAAb,aAAa;sBAnBpE,WAAW;uBAUV,cAAc;2BAQV,WAAW;uCACuC,aAAa"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core-manager/index.js"],"names":[],"mappings":"AAwBA,kDAAqE;AAErE,kDAAkD;AAClD,8EAA8E;AAC9E;;;;;GAKG;AAEH;;GAEG;AACH;IAiBE,kFAEC;IAED;;;;;;;;;;OAUG;IACH,8GATG;QAA4E,EAAE,EAAtE,OAAO,4BAA4B,EAAE,qBAAqB;QACd,UAAU,EAAtD,2CAAkC;QAClB,UAAU,EAA1B,MAAM;QACW,gBAAgB;QACY,cAAc;QACb,OAAO,EAArD,OAAO,WAAW,EAAE,gBAAgB;QAClB,YAAY;QACb,MAAM;KAAC,EAyHlC;IAED,uBAEC;IAED,wBAEC;IAED,oCAEC;IAED;;;;OAIG;IACH,SAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,yBAFW,SAAS,cAInB;IAED;;;;OAIG;IACH,oBAFW,SAAS,gBAInB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,IAAI,GAAG,SAAS,CAK5B;IAED;;;;;OAKG;IACH,oCAHW,MAAM,GACJ,UAAU,GAAG,SAAS,CAOlC;IAED;;;OAGG;IACH,uBAQC;IAED;;;;;;OAMG;IACH,aAJW,MAAM,aACN,SAAS,GACP,UAAU,CAItB;IAiJD;;;OAGG;IACH,gCAHW,UAAU,QACV,aAAa,QAIvB;IAgDD;;;OAGG;IACH,4BAHW,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,GACxB,OAAO,CAAC,IAAI,CAAC,CAgBzB;IAhCD;;;;;;;;OAQG;IACH,gCAFW,UAAU,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,qBAK/C;;CAqBF;mBArda,UAAU,QAAQ,EAAE,MAAM,CAAC;yBAC3B;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,SAAS,CAAA;CAAE;;gBAGjD,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI;iBAChC,CAAC,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE;QAAE,eAAe,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,KAAK,IAAI;4BACtH,CAAC,UAAU,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI;;;kBAmdvD,MAAM;WACN,MAAM;cACN,WAAW;eACX,SAAS;;6BAtfM,oBAAoB;+BAoB4B,aAAa;gCAAb,aAAa;mCAAb,aAAa;sBAnBpE,WAAW;uBAUV,cAAc;2BAQV,WAAW;uCACuC,aAAa"}

package/dist/datastore/index.d.ts

@@ -44,7 +44,7 @@ export class DataStore<TNamespace extends keyof NamespaceSchemas = "auth" | "con
     });
     get indexer(): MultiCoreIndexer<"binary">;
     get namespace(): TNamespace;
-    get schemas(): ("track" | "remoteDetectionAlert" | "observation")[] | ("translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo")[] | ("role" | "coreOwnership")[];
+    get schemas(): ("observation" | "track" | "remoteDetectionAlert")[] | ("translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon")[] | ("coreOwnership" | "role")[];
     get writerCore(): import("../core-manager/index.js").Core;
     /**
      * UNSAFE: Does not check links: [] refer to a valid doc - should only be used

package/dist/datatype/index.d.ts

@@ -1,112 +1,142 @@
-// Typescript was incorrectly compiling declaration files for this, so the
-// declaration for DataType is written manually below, and copied into the
-// `dist` folder at build-time. The types are checked in `test-types/data-types.ts`
-
-import { type MapeoDoc, type MapeoValue } from '@comapeo/schema'
-import {
-  type MapeoDocMap,
-  type MapeoValueMap,
-  type CoreOwnershipWithSignaturesValue,
-} from '../types.js'
-import { type BetterSQLite3Database } from 'drizzle-orm/better-sqlite3'
-import { SQLiteSelectBase } from 'drizzle-orm/sqlite-core'
-import { RunResult } from 'better-sqlite3'
-import type Hypercore from 'hypercore'
-import { TypedEmitter } from 'tiny-typed-emitter'
-import TranslationApi from '../translation-api.js'
-
-type MapeoDocTableName = `${MapeoDoc['schemaName']}Table`
-type GetMapeoDocTables<T> = T[keyof T & MapeoDocTableName]
-/** Union of Drizzle schema tables that correspond to MapeoDoc types (e.g. excluding backlink tables and other utility tables) */
-type MapeoDocTables =
-  | GetMapeoDocTables<typeof import('../schema/project.js')>
-  | GetMapeoDocTables<typeof import('../schema/client.js')>
-type MapeoDocTablesMap = {
-  [K in MapeoDocTables['_']['name']]: Extract<
-    MapeoDocTables,
-    { _: { name: K } }
-  >
-}
-export interface DataTypeEvents<TDoc extends MapeoDoc> {
-  'updated-docs': (docs: TDoc[]) => void
-}
-
-export const kCreateWithDocId: unique symbol
-export const kSelect: unique symbol
-export const kTable: unique symbol
-export const kDataStore: unique symbol
-
-type OmitUnion<T, K extends keyof any> = T extends any ? Omit<T, K> : never
-type ExcludeSchema<
-  T extends MapeoValue,
-  S extends MapeoValue['schemaName']
-> = Exclude<T, { schemaName: S }>
-
-export class DataType<
-  TDataStore extends import('../datastore/index.js').DataStore,
-  TTable extends MapeoDocTables,
-  TSchemaName extends TTable['_']['name'],
-  TDoc extends MapeoDocMap[TSchemaName],
-  TValue extends MapeoValueMap[TSchemaName]
-> extends TypedEmitter<DataTypeEvents<TDoc>> {
-  constructor({
-    dataStore,
-    table,
-    db,
-    getTranslations,
-  }: {
-    table: TTable
-    dataStore: TDataStore
-    db: import('drizzle-orm/better-sqlite3').BetterSQLite3Database
-    getTranslations: TranslationApi['get']
-  })
-
-  get [kTable](): TTable
-
-  get [kDataStore](): TDataStore
-
-  get schemaName(): TSchemaName
-
-  get namespace(): TDataStore.namespace
-
-  [kCreateWithDocId](
-    docId: string,
-    value:
-      | ExcludeSchema<TValue, 'coreOwnership'>
-      | CoreOwnershipWithSignaturesValue
-  ): Promise<TDoc & { forks: string[] }>
-
-  [kSelect](): Promise<SQLiteSelectBase<TTable, 'sync', RunResult>>
-
-  create<
-    T extends import('type-fest').Exact<
-      ExcludeSchema<TValue, 'coreOwnership'>,
-      T
-    >
-  >(value: T): Promise<TDoc & { forks: string[] }>
-
-  getByDocId(
-    docId: string,
-    opts?: { mustBeFound?: true; lang?: string }
-  ): Promise<TDoc & { forks: string[] }>
-  getByDocId(
-    docId: string,
-    opts?: { mustBeFound?: boolean; lang?: string }
-  ): Promise<null | (TDoc & { forks: string[] })>
-
-  getByVersionId(versionId: string, opts?: { lang?: string }): Promise<TDoc>
-
-  getMany(opts?: {
-    includeDeleted?: boolean
-    lang?: string
-  }): Promise<Array<TDoc & { forks: string[] }>>
-
-  update<
-    T extends import('type-fest').Exact<
-      ExcludeSchema<TValue, 'coreOwnership'>,
-      T
-    >
-  >(versionId: string | string[], value: T): Promise<TDoc & { forks: string[] }>
-
-  delete(docId: string): Promise<TDoc & { forks: string[] }>
+export const kCreateWithDocId: unique symbol;
+export const kSelect: unique symbol;
+export const kTable: unique symbol;
+export const kDataStore: unique symbol;
+/**
+ * @template {DataStore} TDataStore
+ * @template {MapeoDocTables} TTable
+ * @template {TTable['_']['name']} TSchemaName
+ * @template {MapeoDocMap[TSchemaName]} TDoc
+ * @template {MapeoValueMap[TSchemaName]} TValue
+ * @extends {TypedEmitter<DataTypeEvents<TDoc> & DefaultEmitterEvents<DataTypeEvents<TDoc>>>}
+ */
+export class DataType<TDataStore extends DataStore, TTable extends MapeoDocTables, TSchemaName extends TTable["_"]["name"], TDoc extends MapeoDocMap[TSchemaName], TValue extends MapeoValueMap[TSchemaName]> extends TypedEmitter<DataTypeEvents<TDoc> & DefaultEmitterEvents<DataTypeEvents<TDoc>>> {
+    /**
+     *
+     * @param {object} opts
+     * @param {TTable} opts.table
+     * @param {TDataStore} opts.dataStore
+     * @param {import('drizzle-orm/better-sqlite3').BetterSQLite3Database} opts.db
+     * @param {import('../translation-api.js').default['get']} opts.getTranslations
+     */
+    constructor({ dataStore, table, db, getTranslations }: {
+        table: TTable;
+        dataStore: TDataStore;
+        db: import("drizzle-orm/better-sqlite3").BetterSQLite3Database;
+        getTranslations: import("../translation-api.js").default["get"];
+    });
+    /** @returns {TSchemaName} */
+    get schemaName(): TSchemaName;
+    /** @returns {TDataStore['namespace']} */
+    get namespace(): TDataStore["namespace"];
+    /**
+     * @template {Exact<ExcludeSchema<TValue, 'coreOwnership'>, T>} T
+     * @param {T} value
+     * @returns {Promise<TDoc & { forks: string[] }>}
+     */
+    create<T extends Exact<ExcludeSchema<TValue, "coreOwnership">, T>>(value: T): Promise<TDoc & {
+        forks: string[];
+    }>;
+    /**
+     * @overload
+     * @param {string} docId
+     * @param {object} [options]
+     * @param {true} [options.mustBeFound]
+     * @param {string} [options.lang]
+     * @returns {Promise<TDoc & { forks: string[] }>}
+     */
+    getByDocId(docId: string, options?: {
+        mustBeFound?: true | undefined;
+        lang?: string | undefined;
+    } | undefined): Promise<TDoc & {
+        forks: string[];
+    }>;
+    /**
+     * @param {string} versionId
+     * @param {{ lang?: string }} [opts]
+     * @returns {Promise<TDoc>}
+     */
+    getByVersionId(versionId: string, { lang }?: {
+        lang?: string;
+    } | undefined): Promise<TDoc>;
+    /**
+     * @param {object} opts
+     * @param {boolean} [opts.includeDeleted]
+     * @param {string} [opts.lang]
+     * @returns {Promise<Array<TDoc & { forks: string[] }>>}
+     */
+    getMany({ includeDeleted, lang }?: {
+        includeDeleted?: boolean | undefined;
+        lang?: string | undefined;
+    }): Promise<Array<TDoc & {
+        forks: string[];
+    }>>;
+    /**
+     * @template {Exact<ExcludeSchema<TValue, 'coreOwnership'>, T>} T
+     * @param {string | string[]} versionId
+     * @param {T} value
+     * @returns {Promise<TDoc & { forks: string[] }>}
+     */
+    update<T extends Exact<ExcludeSchema<TValue, "coreOwnership">, T>>(versionId: string | string[], value: T): Promise<TDoc & {
+        forks: string[];
+    }>;
+    /**
+     * @param {string} docId
+     * @returns {Promise<TDoc & { forks: string[] }>}
+     */
+    delete(docId: string): Promise<TDoc & {
+        forks: string[];
+    }>;
+    /** @returns {TTable} */
+    get [kTable](): TTable;
+    /** @returns {TDataStore} */
+    get [kDataStore](): TDataStore;
+    /**
+     * @param {string} docId
+     * @param {ExcludeSchema<TValue, 'coreOwnership'> | CoreOwnershipWithSignaturesValue} value
+     * @param {{ checkExisting?: boolean }} [opts] - only used internally to skip the checkExisting check when creating a document with a random ID (collisions should be too small probability to be worth checking for)
+     * @returns {Promise<TDoc & { forks: string[] }>}
+     */
+    [kCreateWithDocId](docId: string, value: ExcludeSchema<TValue, "coreOwnership"> | CoreOwnershipWithSignaturesValue, { checkExisting }?: {
+        checkExisting?: boolean;
+    } | undefined): Promise<TDoc & {
+        forks: string[];
+    }>;
+    [kSelect](): Promise<Omit<SQLiteSelectBase<import("drizzle-orm/query-builders/select.types").GetSelectTableName<TTable>, "sync", RunResult, import("drizzle-orm/query-builders/select.types").GetSelectTableSelection<TTable>, "single", import("drizzle-orm/query-builders/select.types").GetSelectTableName<TTable> extends infer T ? T extends import("drizzle-orm/query-builders/select.types").GetSelectTableName<TTable> ? T extends string ? Record<T, "not-null"> : {} : never : never, false, never, ({ [Key in keyof import("drizzle-orm/query-builders/select.types").GetSelectTableSelection<TTable> & string]: import("drizzle-orm/query-builders/select.types").SelectResultField<import("drizzle-orm/query-builders/select.types").GetSelectTableSelection<TTable>[Key], true>; } extends infer T_1 ? { [K in keyof T_1]: { [Key in keyof import("drizzle-orm/query-builders/select.types").GetSelectTableSelection<TTable> & string]: import("drizzle-orm/query-builders/select.types").SelectResultField<import("drizzle-orm/query-builders/select.types").GetSelectTableSelection<TTable>[Key], true>; }[K]; } : never)[], import("drizzle-orm/query-builders/select.types").BuildSubquerySelection<import("drizzle-orm/query-builders/select.types").GetSelectTableSelection<TTable>, import("drizzle-orm/query-builders/select.types").GetSelectTableName<TTable> extends infer T ? T extends import("drizzle-orm/query-builders/select.types").GetSelectTableName<TTable> ? T extends string ? Record<T, "not-null"> : {} : never : never>>, "then" | "catch" | "finally"> & {
+        then?: undefined;
+        catch?: undefined;
+        finally?: undefined;
+    }>;
+    #private;
 }
+export type MapeoDocTableName = `${MapeoDoc["schemaName"]}Table`;
+export type GetMapeoDocTables<T> = T[(keyof T) & MapeoDocTableName];
+/**
+ * Union of Drizzle schema tables that correspond to MapeoDoc types (e.g. excluding backlink tables and other utility tables)
+ */
+export type MapeoDocTables = GetMapeoDocTables<typeof import("../schema/project.js")> | GetMapeoDocTables<typeof import("../schema/client.js")>;
+export type MapeoDocTablesMap = { [K in MapeoDocTables["_"]["name"]]: Extract<MapeoDocTables, {
+    _: {
+        name: K;
+    };
+}>; };
+export type OmitUnion<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type ExcludeSchema<T extends MapeoValue, S extends MapeoValue["schemaName"]> = Exclude<T, {
+    schemaName: S;
+}>;
+export type DataTypeEvents<TDoc extends MapeoDoc> = {
+    "updated-docs": (docs: TDoc[]) => void;
+};
+import type { DataStore } from '../datastore/index.js';
+import type { MapeoDocMap } from '../types.js';
+import type { MapeoValueMap } from '../types.js';
+import type { DefaultEmitterEvents } from '../types.js';
+import { TypedEmitter } from 'tiny-typed-emitter';
+import type { Exact } from 'type-fest';
+import type { CoreOwnershipWithSignaturesValue } from '../types.js';
+import type { RunResult } from 'better-sqlite3';
+import type { SQLiteSelectBase } from 'drizzle-orm/sqlite-core';
+import type { MapeoDoc } from '@comapeo/schema';
+import type { MapeoValue } from '@comapeo/schema';
+import type { MapeoDoc as MapeoDoc_1 } from '@comapeo/schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/datatype/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/datatype/index.js"],"names":[],"mappings":"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"}

package/dist/fastify-plugins/utils.d.ts

@@ -6,15 +6,6 @@
 export function getFastifyServerAddress(server: import("node:http").Server, { timeout }?: {
     timeout?: number;
 } | undefined): Promise<string>;
-/**
- * @param {Readonly<Date>} lastModified
- */
-export function createStyleJsonResponseHeaders(lastModified: Readonly<Date>): {
-    'Cache-Control': string;
-    'Access-Control-Allow-Headers': string;
-    'Access-Control-Allow-Origin': string;
-    'Last-Modified': string;
-};
 export const NotFoundError: createError.FastifyErrorConstructor<{
     code: "FST_RESOURCE_NOT_FOUND";
     statusCode: 404;

package/dist/fastify-plugins/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/fastify-plugins/utils.js"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,gDAJW,OAAO,WAAW,EAAE,MAAM;cACd,MAAM;gBAChB,OAAO,CAAC,MAAM,CAAC,CA0B3B;AAED;;GAEG;AACH,6DAFW,QAAQ,CAAC,IAAI,CAAC;;;;;EAUxB;AAtDD;;;uBAIC;AAED;;;uBAIC;wBAZuB,gBAAgB"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/fastify-plugins/utils.js"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,gDAJW,OAAO,WAAW,EAAE,MAAM;cACd,MAAM;gBAChB,OAAO,CAAC,MAAM,CAAC,CA0B3B;AAzCD;;;uBAIC;AAED;;;uBAIC;wBAZuB,gBAAgB"}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { plugin as CoMapeoMapsFastifyPlugin } from "./fastify-plugins/maps.js";
 export { FastifyController } from "./fastify-controller.js";
 export { MapeoManager } from "./mapeo-manager.js";
-export function replicateProject(project: MapeoProject, isInitiatorOrStream: boolean | import("stream").Duplex | import("streamx").Duplex<any, any, any, any, true, true, import("streamx").DuplexEvents<any, any>>): ReturnType<(isInitiatorOrStream: (boolean | import("stream").Duplex | import("streamx").Duplex)) => import("./types.js").ReplicationStream>;
+export function replicateProject(project: MapeoProject, isInitiatorOrStream: boolean | import("streamx").Duplex<any, any, any, any, true, true, import("streamx").DuplexEvents<any, any>> | import("stream").Duplex): ReturnType<(isInitiatorOrStream: (boolean | import("stream").Duplex | import("streamx").Duplex)) => import("./types.js").ReplicationStream>;
 export namespace roles {
     export { CREATOR_ROLE_ID };
     export { COORDINATOR_ROLE_ID };

package/dist/mapeo-project.d.ts

@@ -58,7 +58,7 @@ export class MapeoProject extends TypedEmitter<{
     /**
      */
     close(): Promise<void>;
-    get observation(): DataType<DataStore<"data", "track" | "remoteDetectionAlert" | "observation">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    get observation(): DataType<DataStore<"data", "observation" | "track" | "remoteDetectionAlert">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
         name: "observation";
         schema: undefined;
         columns: {
@@ -328,7 +328,7 @@ export class MapeoProject extends TypedEmitter<{
             versionId: string;
         } | undefined;
     }>;
-    get track(): DataType<DataStore<"data", "track" | "remoteDetectionAlert" | "observation">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    get track(): DataType<DataStore<"data", "observation" | "track" | "remoteDetectionAlert">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
         name: "track";
         schema: undefined;
         columns: {
@@ -511,7 +511,7 @@ export class MapeoProject extends TypedEmitter<{
             [k: string]: boolean | number | string | null | (boolean | number | string | null)[];
         };
     }>;
-    get preset(): DataType<DataStore<"config", "translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    get preset(): DataType<DataStore<"config", "translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
         name: "preset";
         schema: undefined;
         columns: {
@@ -781,7 +781,7 @@ export class MapeoProject extends TypedEmitter<{
         terms: string[];
         color?: string | undefined;
     }>;
-    get field(): DataType<DataStore<"config", "translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    get field(): DataType<DataStore<"config", "translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
         name: "field";
         schema: undefined;
         columns: {
@@ -1042,7 +1042,7 @@ export class MapeoProject extends TypedEmitter<{
         placeholder?: string | undefined;
         helperText?: string | undefined;
     }>;
-    get remoteDetectionAlert(): DataType<DataStore<"data", "track" | "remoteDetectionAlert" | "observation">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    get remoteDetectionAlert(): DataType<DataStore<"data", "observation" | "track" | "remoteDetectionAlert">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
         name: "remoteDetectionAlert";
         schema: undefined;
         columns: {
@@ -1286,7 +1286,7 @@ export class MapeoProject extends TypedEmitter<{
      * DataTypes object mappings, used for tests
      */
     get [kDataTypes](): {
-        observation: DataType<DataStore<"data", "track" | "remoteDetectionAlert" | "observation">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        observation: DataType<DataStore<"data", "observation" | "track" | "remoteDetectionAlert">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "observation";
             schema: undefined;
             columns: {
@@ -1556,7 +1556,7 @@ export class MapeoProject extends TypedEmitter<{
                 versionId: string;
             } | undefined;
         }>;
-        track: DataType<DataStore<"data", "track" | "remoteDetectionAlert" | "observation">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        track: DataType<DataStore<"data", "observation" | "track" | "remoteDetectionAlert">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "track";
             schema: undefined;
             columns: {
@@ -1739,7 +1739,7 @@ export class MapeoProject extends TypedEmitter<{
                 [k: string]: boolean | number | string | null | (boolean | number | string | null)[];
             };
         }>;
-        remoteDetectionAlert: DataType<DataStore<"data", "track" | "remoteDetectionAlert" | "observation">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        remoteDetectionAlert: DataType<DataStore<"data", "observation" | "track" | "remoteDetectionAlert">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "remoteDetectionAlert";
             schema: undefined;
             columns: {
@@ -1941,7 +1941,7 @@ export class MapeoProject extends TypedEmitter<{
             };
             geometry: import("@comapeo/schema/dist/schema/remoteDetectionAlert.js").Geometry;
         }>;
-        preset: DataType<DataStore<"config", "translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        preset: DataType<DataStore<"config", "translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "preset";
             schema: undefined;
             columns: {
@@ -2211,7 +2211,7 @@ export class MapeoProject extends TypedEmitter<{
             terms: string[];
             color?: string | undefined;
         }>;
-        field: DataType<DataStore<"config", "translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        field: DataType<DataStore<"config", "translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "field";
             schema: undefined;
             columns: {
@@ -2472,7 +2472,7 @@ export class MapeoProject extends TypedEmitter<{
             placeholder?: string | undefined;
             helperText?: string | undefined;
         }>;
-        projectSettings: DataType<DataStore<"config", "translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        projectSettings: DataType<DataStore<"config", "translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "projectSettings";
             schema: undefined;
             columns: {
@@ -2673,7 +2673,7 @@ export class MapeoProject extends TypedEmitter<{
                 fileVersion: string;
             } | undefined;
         }>;
-        coreOwnership: DataType<DataStore<"auth", "role" | "coreOwnership">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        coreOwnership: DataType<DataStore<"auth", "coreOwnership" | "role">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "coreOwnership";
             schema: undefined;
             columns: {
@@ -2869,7 +2869,7 @@ export class MapeoProject extends TypedEmitter<{
             blobCoreId: string;
             blobIndexCoreId: string;
         }>;
-        role: DataType<DataStore<"auth", "role" | "coreOwnership">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        role: DataType<DataStore<"auth", "coreOwnership" | "role">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "role";
             schema: undefined;
             columns: {
@@ -3023,7 +3023,7 @@ export class MapeoProject extends TypedEmitter<{
             roleId: string;
             fromIndex: number;
         }>;
-        deviceInfo: DataType<DataStore<"config", "translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        deviceInfo: DataType<DataStore<"config", "translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "deviceInfo";
             schema: undefined;
             columns: {
@@ -3197,7 +3197,7 @@ export class MapeoProject extends TypedEmitter<{
                 baseUrl: string;
             } | undefined;
         }>;
-        icon: DataType<DataStore<"config", "translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        icon: DataType<DataStore<"config", "translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "icon";
             schema: undefined;
             columns: {
@@ -3378,7 +3378,7 @@ export class MapeoProject extends TypedEmitter<{
                 blobVersionId: import("@comapeo/schema/dist/schema/icon.js").BlobVersionId;
             })[];
         }>;
-        translation: DataType<DataStore<"config", "translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+        translation: DataType<DataStore<"config", "translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
             name: "translation";
             schema: undefined;
             columns: {
@@ -3498,7 +3498,7 @@ export class MapeoProject extends TypedEmitter<{
                     tableName: "translation";
                     dataType: "string";
                     columnType: "SQLiteText";
-                    data: "track" | "role" | "projectSettings" | "preset" | "observation" | "field" | "deviceInfo" | "UNRECOGNIZED" | "type_unspecified";
+                    data: "UNRECOGNIZED" | "observation" | "track" | "preset" | "field" | "projectSettings" | "deviceInfo" | "role" | "type_unspecified";
                     driverParam: string;
                     notNull: true;
                     hasDefault: false;

package/dist/schema/project.d.ts

@@ -118,7 +118,7 @@ export const translationTable: import("drizzle-orm/sqlite-core").SQLiteTableWith
             tableName: "translation";
             dataType: "string";
             columnType: "SQLiteText";
-            data: "track" | "role" | "projectSettings" | "preset" | "observation" | "field" | "deviceInfo" | "UNRECOGNIZED" | "type_unspecified";
+            data: "UNRECOGNIZED" | "observation" | "track" | "preset" | "field" | "projectSettings" | "deviceInfo" | "role" | "type_unspecified";
             driverParam: string;
             notNull: true;
             hasDefault: false;

package/dist/translation-api.d.ts

@@ -58,7 +58,7 @@ export default class TranslationApi {
      * @param {TranslationValue} doc
      */
     index(doc: TranslationValue): void;
-    get dataType(): import("./datatype/index.js").DataType<import("./datastore/index.js").DataStore<"config", "translation" | "projectSettings" | "preset" | "icon" | "field" | "deviceInfo">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    get dataType(): import("./datatype/index.js").DataType<import("./datastore/index.js").DataStore<"config", "translation" | "preset" | "field" | "projectSettings" | "deviceInfo" | "icon">, import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
         name: "translation";
         schema: undefined;
         columns: {
@@ -178,7 +178,7 @@ export default class TranslationApi {
                 tableName: "translation";
                 dataType: "string";
                 columnType: "SQLiteText";
-                data: "track" | "role" | "projectSettings" | "preset" | "observation" | "field" | "deviceInfo" | "UNRECOGNIZED" | "type_unspecified";
+                data: "UNRECOGNIZED" | "observation" | "track" | "preset" | "field" | "projectSettings" | "deviceInfo" | "role" | "type_unspecified";
                 driverParam: string;
                 notNull: true;
                 hasDefault: false;

package/dist/translation-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translation-api.d.ts","sourceRoot":"","sources":["../src/translation-api.js"],"names":[],"mappings":"AAKA,uEAAuE;AACvE,+CAA+C;AAE/C,iEAEC;AACD;IAQE;;;;;;;;;OASG;IACH,0BARG;QAMS,QAAQ,EANT,OAAO,qBAAqB,EAAE,QAAQ,CAChD,OAAW,sBAAsB,EAAE,SAAS,CAAC,QAAQ,CAAC,EACtD,cAAkB,qBAAqB,EAAE,gBAAgB,EACzD,aAAiB,EACjB,WAAe,EACf,gBAAoB,CACjB;KACH,EAWA;IAED,+BAA+B;IAC/B,SADc,OAAO,CAAC,IAAI,CAAC,CAG1B;IAED;;OAEG;IACH,WAFW,gBAAgB;;;;;;;;;;;;;;;;;;;;OAW1B;IAED,kGAAkG;IAElG;;;;;OAKG;IACH,WALW,YACR,IAAI,CAAC,gBAAgB,EAAC,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC,EAC5D,aAAe,GAAG,YAAY,CAAC,GAAG;QAAC,MAAM;;;UAA6B;KAAC,GAC3D,OAAO,CAAC,OAAO,iBAAiB,EAAE,WAAW,EAAE,CAAC,CAqC5D;IAED;;OAEG;IACH,WAFW,gBAAgB,QAkB1B;IAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IALD,mHAEC;;CAIF;sCAhIkD,iBAAiB;iCACnC,WAAW;iCADO,iBAAiB"}
+{"version":3,"file":"translation-api.d.ts","sourceRoot":"","sources":["../src/translation-api.js"],"names":[],"mappings":"AAKA,uEAAuE;AACvE,+CAA+C;AAE/C,iEAEC;AACD;IAQE;;;;;;;;;OASG;IACH,0BARG;QAMS,QAAQ,EANT,OAAO,qBAAqB,EAAE,QAAQ,CAChD,OAAW,sBAAsB,EAAE,SAAS,CAAC,QAAQ,CAAC,EACtD,cAAkB,qBAAqB,EAAE,gBAAgB,EACzD,aAAiB,EACjB,WAAe,EACf,gBAAoB,CACjB;KACH,EAWA;IAED,+BAA+B;IAC/B,SADc,OAAO,CAAC,IAAI,CAAC,CAG1B;IAED;;OAEG;IACH,WAFW,gBAAgB;;;;;;;;;;;;;;;;;;;;OAW1B;IAED,kGAAkG;IAElG;;;;;OAKG;IACH,WALW,YACR,IAAI,CAAC,gBAAgB,EAAC,YAAY,GAAG,SAAS,GAAG,QAAQ,CAAC,EAC5D,aAAe,GAAG,YAAY,CAAC,GAAG;QAAC,MAAM;;;UAA6B;KAAC,GAC3D,OAAO,CAAC,OAAO,iBAAiB,EAAE,WAAW,EAAE,CAAC,CAsC5D;IAED;;OAEG;IACH,WAFW,gBAAgB,QAkB1B;IAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAEC;IALD,mHAEC;;CAIF;sCAjIkD,iBAAiB;iCACnC,WAAW;iCADO,iBAAiB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comapeo/core",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "Offline p2p mapping library",
   "main": "src/index.js",
   "types": "dist/index.d.ts",
@@ -110,6 +110,7 @@
     "@bufbuild/buf": "^1.26.1",
     "@comapeo/cloud": "^0.1.0",
     "@comapeo/core2.0.1": "npm:@comapeo/core@2.0.1",
+    "@comapeo/ipc": "^2.1.0",
     "@mapeo/default-config": "5.0.0",
     "@mapeo/mock-data": "^2.1.1",
     "@sinonjs/fake-timers": "^10.0.2",
@@ -158,14 +159,14 @@
   },
   "dependencies": {
     "@comapeo/fallback-smp": "^1.0.0",
-    "@comapeo/schema": "1.3.0",
+    "@comapeo/schema": "1.4.1",
     "@digidem/types": "^2.3.0",
     "@fastify/error": "^3.4.1",
     "@fastify/type-provider-typebox": "^4.1.0",
     "@hyperswarm/secret-stream": "^6.6.3",
     "@mapeo/crypto": "1.0.0-alpha.10",
     "@mapeo/sqlite-indexer": "1.0.0-alpha.9",
-    "@sinclair/typebox": "^0.29.6",
+    "@sinclair/typebox": "^0.33.17",
     "@sindresorhus/merge-streams": "^4.0.0",
     "b4a": "^1.6.3",
     "bcp-47": "^2.1.0",

package/src/core-manager/index.js

@@ -41,7 +41,6 @@ export class CoreManager extends TypedEmitter {
   #coreIndex
   /** @type {CoreRecord} */
   #creatorCoreRecord
-  #projectKey
   #queries
   #encryptionKeys
   #projectExtension
@@ -93,7 +92,6 @@ export class CoreManager extends TypedEmitter {
     this.#l = Logger.create('coreManager', logger)
     const primaryKey = keyManager.getDerivedKey('primaryKey', projectKey)
     this.#deviceId = keyManager.getIdentityKeypair().publicKey.toString('hex')
-    this.#projectKey = projectKey
     this.#encryptionKeys = encryptionKeys
     this.#autoDownload = autoDownload
 

package/src/datatype/index.js

@@ -8,29 +8,57 @@ import { TypedEmitter } from 'tiny-typed-emitter'
 import { parse as parseBCP47 } from 'bcp-47'
 import { setProperty, getProperty } from 'dot-prop'
 /** @import { MapeoDoc, MapeoValue } from '@comapeo/schema' */
-/** @import { MapeoDocMap, MapeoValueMap } from '../types.js' */
+/** @import { RunResult } from 'better-sqlite3' */
+/** @import { SQLiteSelectBase } from 'drizzle-orm/sqlite-core' */
+/** @import { Exact } from 'type-fest' */
 /** @import { DataStore } from '../datastore/index.js' */
+/**
+ * @import {
+ *   CoreOwnershipWithSignaturesValue,
+ *   DefaultEmitterEvents,
+ *   MapeoDocMap,
+ *   MapeoValueMap,
+ * } from '../types.js'
+ */
 
 /**
+ * @internal
  * @typedef {`${MapeoDoc['schemaName']}Table`} MapeoDocTableName
  */
+
 /**
+ * @internal
  * @template T
  * @typedef {T[(keyof T) & MapeoDocTableName]} GetMapeoDocTables
  */
+
 /**
  * Union of Drizzle schema tables that correspond to MapeoDoc types (e.g. excluding backlink tables and other utility tables)
+ * @internal
  * @typedef {GetMapeoDocTables<typeof import('../schema/project.js')> | GetMapeoDocTables<typeof import('../schema/client.js')>} MapeoDocTables
  */
+
 /**
+ * @internal
  * @typedef {{ [K in MapeoDocTables['_']['name']]: Extract<MapeoDocTables, { _: { name: K }}> }} MapeoDocTablesMap
  */
+
 /**
+ * @internal
  * @template T
  * @template {keyof any} K
  * @typedef {T extends any ? Omit<T, K> : never} OmitUnion
  */
+
+/**
+ * @internal
+ * @template {MapeoValue} T
+ * @template {MapeoValue['schemaName']} S
+ * @typedef {Exclude<T, { schemaName: S }>} ExcludeSchema
+ */
+
 /**
+ * @internal
  * @template {MapeoDoc} TDoc
  * @typedef {object} DataTypeEvents
  * @property {(docs: TDoc[]) => void} updated-docs
@@ -49,11 +77,11 @@ export const kDataStore = Symbol('dataStore')
 
 /**
  * @template {DataStore} TDataStore
- * @template {TDataStore['schemas'][number]} TSchemaName
- * @template {MapeoDocTablesMap[TSchemaName]} TTable
- * @template {Exclude<MapeoDocMap[TSchemaName], { schemaName: 'coreOwnership' }>} TDoc
- * @template {Exclude<MapeoValueMap[TSchemaName], { schemaName: 'coreOwnership' }>} TValue
- * @extends {TypedEmitter<DataTypeEvents<TDoc> & import('../types.js').DefaultEmitterEvents<DataTypeEvents<TDoc>>>}
+ * @template {MapeoDocTables} TTable
+ * @template {TTable['_']['name']} TSchemaName
+ * @template {MapeoDocMap[TSchemaName]} TDoc
+ * @template {MapeoValueMap[TSchemaName]} TValue
+ * @extends {TypedEmitter<DataTypeEvents<TDoc> & DefaultEmitterEvents<DataTypeEvents<TDoc>>>}
  */
 export class DataType extends TypedEmitter {
   #dataStore
@@ -106,36 +134,42 @@ export class DataType extends TypedEmitter {
     })
   }
 
+  /** @returns {TTable} */
   get [kTable]() {
     return this.#table
   }
 
+  /** @returns {TSchemaName} */
   get schemaName() {
     return this.#schemaName
   }
 
+  /** @returns {TDataStore['namespace']} */
   get namespace() {
     return this.#dataStore.namespace
   }
 
+  /** @returns {TDataStore} */
   get [kDataStore]() {
     return this.#dataStore
   }
 
   /**
-   * @template {import('type-fest').Exact<TValue, T>} T
+   * @template {Exact<ExcludeSchema<TValue, 'coreOwnership'>, T>} T
    * @param {T} value
+   * @returns {Promise<TDoc & { forks: string[] }>}
    */
   async create(value) {
     const docId = generateId()
-    // @ts-expect-error - can't figure this one out, types in index.d.ts override this
+    // @ts-expect-error - can't figure this one out
     return this[kCreateWithDocId](docId, value, { checkExisting: false })
   }
 
   /**
    * @param {string} docId
-   * @param {TValue | import('../types.js').CoreOwnershipWithSignaturesValue} value
+   * @param {ExcludeSchema<TValue, 'coreOwnership'> | CoreOwnershipWithSignaturesValue} value
    * @param {{ checkExisting?: boolean }} [opts] - only used internally to skip the checkExisting check when creating a document with a random ID (collisions should be too small probability to be worth checking for)
+   * @returns {Promise<TDoc & { forks: string[] }>}
    */
   async [kCreateWithDocId](docId, value, { checkExisting = true } = {}) {
     if (!validate(this.#schemaName, value)) {
@@ -193,15 +227,18 @@ export class DataType extends TypedEmitter {
   /**
    * @param {string} versionId
    * @param {{ lang?: string }} [opts]
+   * @returns {Promise<TDoc>}
    */
   async getByVersionId(versionId, { lang } = {}) {
     const result = await this.#dataStore.read(versionId)
-    return this.#translate(result, { lang })
+    if (result.schemaName !== this.#schemaName) throw new NotFoundError()
+    return this.#translate(deNullify(result), { lang })
   }
 
   /**
    * @param {any} doc
    * @param {{ lang?: string }} [opts]
+   * @returns {Promise<TDoc & { forks: string[] }>}
    */
   async #translate(doc, { lang } = {}) {
     if (!lang) return doc
@@ -235,27 +272,27 @@ export class DataType extends TypedEmitter {
     return doc
   }
 
-  /** @param {{ includeDeleted?: boolean, lang?: string }} [opts] */
+  /**
+   * @param {object} opts
+   * @param {boolean} [opts.includeDeleted]
+   * @param {string} [opts.lang]
+   * @returns {Promise<Array<TDoc & { forks: string[] }>>}
+   */
   async getMany({ includeDeleted = false, lang } = {}) {
     await this.#dataStore.indexer.idle()
     const rows = includeDeleted
       ? this.#sql.getManyWithDeleted.all()
       : this.#sql.getMany.all()
     return await Promise.all(
-      rows.map(
-        async (doc) =>
-          await this.#translate(deNullify(/** @type {MapeoDoc} */ (doc)), {
-            lang,
-          })
-      )
+      rows.map((doc) => this.#translate(deNullify(doc), { lang }))
     )
   }
 
   /**
-   *
-   * @template {import('type-fest').Exact<TValue, T>} T
+   * @template {Exact<ExcludeSchema<TValue, 'coreOwnership'>, T>} T
    * @param {string | string[]} versionId
    * @param {T} value
+   * @returns {Promise<TDoc & { forks: string[] }>}
    */
   async update(versionId, value) {
     await this.#dataStore.indexer.idle()
@@ -279,6 +316,7 @@ export class DataType extends TypedEmitter {
 
   /**
    * @param {string} docId
+   * @returns {Promise<TDoc & { forks: string[] }>}
    */
   async delete(docId) {
     await this.#dataStore.indexer.idle()

package/src/fastify-plugins/maps.js

@@ -120,6 +120,7 @@ export async function plugin(fastify, opts) {
       if (resp && resp.status === 200) {
         return reply
           .headers({
+            'access-control-allow-origin': '*',
             'cache-control': 'no-cache',
           })
           .redirect(url.toString())

package/src/fastify-plugins/utils.js

@@ -43,16 +43,3 @@ export async function getFastifyServerAddress(server, { timeout } = {}) {
 
   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/translation-api.js

@@ -1,6 +1,6 @@
 import { and, sql } from 'drizzle-orm'
 import { kCreateWithDocId, kSelect } from './datatype/index.js'
-import { hashObject } from './utils.js'
+import { deNullify, hashObject } from './utils.js'
 import { nullIfNotFound } from './errors.js'
 import { omit } from './lib/omit.js'
 /** @import { Translation, TranslationValue } from '@comapeo/schema' */
@@ -101,6 +101,7 @@ export default class TranslationApi {
       .where(and.apply(null, filters))
       .prepare()
       .all()
+      .map(deNullify)
   }
 
   /**

package/src/datatype/index.d.ts

@@ -1,112 +0,0 @@
-// Typescript was incorrectly compiling declaration files for this, so the
-// declaration for DataType is written manually below, and copied into the
-// `dist` folder at build-time. The types are checked in `test-types/data-types.ts`
-
-import { type MapeoDoc, type MapeoValue } from '@comapeo/schema'
-import {
-  type MapeoDocMap,
-  type MapeoValueMap,
-  type CoreOwnershipWithSignaturesValue,
-} from '../types.js'
-import { type BetterSQLite3Database } from 'drizzle-orm/better-sqlite3'
-import { SQLiteSelectBase } from 'drizzle-orm/sqlite-core'
-import { RunResult } from 'better-sqlite3'
-import type Hypercore from 'hypercore'
-import { TypedEmitter } from 'tiny-typed-emitter'
-import TranslationApi from '../translation-api.js'
-
-type MapeoDocTableName = `${MapeoDoc['schemaName']}Table`
-type GetMapeoDocTables<T> = T[keyof T & MapeoDocTableName]
-/** Union of Drizzle schema tables that correspond to MapeoDoc types (e.g. excluding backlink tables and other utility tables) */
-type MapeoDocTables =
-  | GetMapeoDocTables<typeof import('../schema/project.js')>
-  | GetMapeoDocTables<typeof import('../schema/client.js')>
-type MapeoDocTablesMap = {
-  [K in MapeoDocTables['_']['name']]: Extract<
-    MapeoDocTables,
-    { _: { name: K } }
-  >
-}
-export interface DataTypeEvents<TDoc extends MapeoDoc> {
-  'updated-docs': (docs: TDoc[]) => void
-}
-
-export const kCreateWithDocId: unique symbol
-export const kSelect: unique symbol
-export const kTable: unique symbol
-export const kDataStore: unique symbol
-
-type OmitUnion<T, K extends keyof any> = T extends any ? Omit<T, K> : never
-type ExcludeSchema<
-  T extends MapeoValue,
-  S extends MapeoValue['schemaName']
-> = Exclude<T, { schemaName: S }>
-
-export class DataType<
-  TDataStore extends import('../datastore/index.js').DataStore,
-  TTable extends MapeoDocTables,
-  TSchemaName extends TTable['_']['name'],
-  TDoc extends MapeoDocMap[TSchemaName],
-  TValue extends MapeoValueMap[TSchemaName]
-> extends TypedEmitter<DataTypeEvents<TDoc>> {
-  constructor({
-    dataStore,
-    table,
-    db,
-    getTranslations,
-  }: {
-    table: TTable
-    dataStore: TDataStore
-    db: import('drizzle-orm/better-sqlite3').BetterSQLite3Database
-    getTranslations: TranslationApi['get']
-  })
-
-  get [kTable](): TTable
-
-  get [kDataStore](): TDataStore
-
-  get schemaName(): TSchemaName
-
-  get namespace(): TDataStore.namespace
-
-  [kCreateWithDocId](
-    docId: string,
-    value:
-      | ExcludeSchema<TValue, 'coreOwnership'>
-      | CoreOwnershipWithSignaturesValue
-  ): Promise<TDoc & { forks: string[] }>
-
-  [kSelect](): Promise<SQLiteSelectBase<TTable, 'sync', RunResult>>
-
-  create<
-    T extends import('type-fest').Exact<
-      ExcludeSchema<TValue, 'coreOwnership'>,
-      T
-    >
-  >(value: T): Promise<TDoc & { forks: string[] }>
-
-  getByDocId(
-    docId: string,
-    opts?: { mustBeFound?: true; lang?: string }
-  ): Promise<TDoc & { forks: string[] }>
-  getByDocId(
-    docId: string,
-    opts?: { mustBeFound?: boolean; lang?: string }
-  ): Promise<null | (TDoc & { forks: string[] })>
-
-  getByVersionId(versionId: string, opts?: { lang?: string }): Promise<TDoc>
-
-  getMany(opts?: {
-    includeDeleted?: boolean
-    lang?: string
-  }): Promise<Array<TDoc & { forks: string[] }>>
-
-  update<
-    T extends import('type-fest').Exact<
-      ExcludeSchema<TValue, 'coreOwnership'>,
-      T
-    >
-  >(versionId: string | string[], value: T): Promise<TDoc & { forks: string[] }>
-
-  delete(docId: string): Promise<TDoc & { forks: string[] }>
-}