@comapeo/core 4.4.0 → 5.0.0

package/src/schema/project.js

@@ -3,47 +3,34 @@
 import { blob, sqliteTable, text } from 'drizzle-orm/sqlite-core'
 import { dereferencedDocSchemas as schemas } from '@comapeo/schema'
 import { NAMESPACES } from '../constants.js'
-import { jsonSchemaToDrizzleColumns as toColumns } from './schema-to-drizzle.js'
-import { backlinkTable } from './utils.js'
+import {
+  comapeoSchemaToDrizzleTable as toDrizzle,
+  backlinkTable,
+} from './comapeo-to-drizzle.js'
 
-export const translationTable = sqliteTable(
-  'translation',
-  toColumns(schemas.translation)
-)
-export const observationTable = sqliteTable(
-  'observation',
-  toColumns(schemas.observation)
-)
-export const trackTable = sqliteTable('track', toColumns(schemas.track))
-export const remoteDetectionAlertTable = sqliteTable(
-  'remoteDetectionAlert',
-  toColumns(schemas.remoteDetectionAlert)
-)
-export const presetTable = sqliteTable('preset', toColumns(schemas.preset))
-export const fieldTable = sqliteTable('field', toColumns(schemas.field))
-export const coreOwnershipTable = sqliteTable(
-  'coreOwnership',
-  toColumns(schemas.coreOwnership)
-)
-export const roleTable = sqliteTable('role', toColumns(schemas.role))
-export const deviceInfoTable = sqliteTable(
-  'deviceInfo',
-  toColumns(schemas.deviceInfo)
-)
-export const iconTable = sqliteTable('icon', toColumns(schemas.icon))
+export const translationTable = toDrizzle(schemas.translation)
+export const observationTable = toDrizzle(schemas.observation)
+export const trackTable = toDrizzle(schemas.track)
+export const remoteDetectionAlertTable = toDrizzle(schemas.remoteDetectionAlert)
+export const presetTable = toDrizzle(schemas.preset)
+export const fieldTable = toDrizzle(schemas.field)
+export const coreOwnershipTable = toDrizzle(schemas.coreOwnership)
+export const roleTable = toDrizzle(schemas.role)
+export const deviceInfoTable = toDrizzle(schemas.deviceInfo)
+export const iconTable = toDrizzle(schemas.icon)
 
-export const translationBacklinkTable = backlinkTable(translationTable)
-export const observationBacklinkTable = backlinkTable(observationTable)
-export const trackBacklinkTable = backlinkTable(trackTable)
+export const translationBacklinkTable = backlinkTable('translation')
+export const observationBacklinkTable = backlinkTable('observation')
+export const trackBacklinkTable = backlinkTable('track')
 export const remoteDetectionAlertBacklinkTable = backlinkTable(
-  remoteDetectionAlertTable
+  'remoteDetectionAlert'
 )
-export const presetBacklinkTable = backlinkTable(presetTable)
-export const fieldBacklinkTable = backlinkTable(fieldTable)
-export const coreOwnershipBacklinkTable = backlinkTable(coreOwnershipTable)
-export const roleBacklinkTable = backlinkTable(roleTable)
-export const deviceInfoBacklinkTable = backlinkTable(deviceInfoTable)
-export const iconBacklinkTable = backlinkTable(iconTable)
+export const presetBacklinkTable = backlinkTable('preset')
+export const fieldBacklinkTable = backlinkTable('field')
+export const coreOwnershipBacklinkTable = backlinkTable('coreOwnership')
+export const roleBacklinkTable = backlinkTable('role')
+export const deviceInfoBacklinkTable = backlinkTable('deviceInfo')
+export const iconBacklinkTable = backlinkTable('icon')
 
 export const coresTable = sqliteTable('cores', {
   publicKey: blob('publicKey', { mode: 'buffer' }).notNull(),

package/src/schema/types.ts

@@ -3,101 +3,86 @@ import {
   JSONSchema7 as JSONSchema7Writable,
   JSONSchema7Type,
 } from 'json-schema'
+import type {
+  SQLiteBooleanBuilder,
+  SQLiteIntegerBuilder,
+  SQLiteRealBuilder,
+  SQLiteTableWithColumns,
+  SQLiteTextBuilder,
+  SQLiteTextJsonBuilder,
+} from 'drizzle-orm/sqlite-core'
+import type {
+  $Type,
+  BuildColumns,
+  ColumnBuilderBase,
+  HasDefault,
+  IsPrimaryKey,
+  NotNull,
+} from 'drizzle-orm'
 
-/** Convert optional properties to nullable */
-export type OptionalToNull<T extends {}> = {
-  [K in keyof T]-?: undefined extends T[K] ? T[K] | null : T[K]
-}
 /** Convert a readonly array/object to writeable */
 type Writable<T> = { -readonly [P in keyof T]: T[P] }
-/** Type returned by text(columnName, { enum: [] }) */
-type TextBuilder<
-  TName extends string,
-  TEnum extends readonly [string, ...string[]],
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteTextBuilder<{
-  name: TName
-  data: Writable<TEnum>[number]
-  driverParam: string
-  columnType: 'SQLiteText'
-  dataType: 'string'
-  enumValues: Writable<TEnum>
-  notNull: TNotNull
-  hasDefault: THasDefault
-}>
-
-/** Type returned by integer(columnName, { mode: 'boolean' }) */
-type BooleanBuilder<
-  TName extends string,
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteBooleanBuilder<{
-  name: TName
-  data: boolean
-  driverParam: number
-  columnType: 'SQLiteBoolean'
-  dataType: 'boolean'
-  notNull: TNotNull
-  hasDefault: THasDefault
-  enumValues: undefined
-}>
-
-/** Type returned by real(columnName) */
-type RealBuilder<
-  TName extends string,
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteRealBuilder<{
-  name: TName
-  data: number
-  driverParam: number
-  columnType: 'SQLiteReal'
-  dataType: 'number'
-  notNull: TNotNull
-  hasDefault: THasDefault
-  enumValues: undefined
-}>
-
-/** Type returned by integer(columnName) */
-type IntegerBuilder<
-  TName extends string,
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteIntegerBuilder<{
-  name: TName
-  data: number
-  driverParam: number
-  columnType: 'SQLiteInteger'
-  dataType: 'number'
-  notNull: TNotNull
-  hasDefault: THasDefault
-  enumValues: undefined
-}>
-
-/** Type returned by the `customJson` custom type */
-type JsonBuilder<
-  TName extends string,
-  TData extends unknown,
-  TNotNull extends boolean,
-  THasDefault extends boolean
-> = import('drizzle-orm/sqlite-core').SQLiteCustomColumnBuilder<{
-  name: TName
-  data: TData
-  dataType: 'custom'
-  driverParam: string
-  columnType: 'SQLiteCustomColumn'
-  notNull: TNotNull
-  hasDefault: THasDefault
-  enumValues: undefined
-}>
 
 export type JSONSchema7 = ReadonlyDeep<JSONSchema7Writable>
 type JsonSchema7Properties = { readonly [K: string]: JSONSchema7 }
-export type JSONSchema7WithProps = Omit<JSONSchema7, 'properties'> & {
+export type JSONSchema7Object = Omit<JSONSchema7, 'properties' | 'type'> & {
+  readonly type: 'object'
   readonly properties: JsonSchema7Properties
 }
 
+/**
+ * Create a Drizzle SQLite table definition from a JSONSchema object. All
+ * top-level properties map to SQLite columns, with `required` properties marked
+ * as `NOT NULL`, and JSONSchema `default` will map to SQLite defaults.
+ *
+ * Any properties that are of type `object` or `array` in the JSONSchema will be
+ * mapped to a text field, which drizzle will parse and stringify. Types for
+ * `object` and `array` properties will be derived from `TObjectType`.
+ */
+export type JsonSchemaToDrizzleSqliteTable<
+  /** Typescript type for the object defined in the JSONSchema */
+  TObjectType extends { [K in keyof TSchema['properties']]?: any },
+  /** The JSONSchema object schema */
+  TSchema extends JSONSchema7Object,
+  /** Name of the table to create */
+  TTableName extends string,
+  /** Additional columns to add to the table definition (e.g. not defined in JSONSchema ) */
+  TColumnsMap extends Record<string, ColumnBuilderBase> = {},
+  /** Name of the property to use as primary key */
+  TPrimaryKey extends keyof TSchema['properties'] | undefined = undefined
+> = SQLiteTableWithColumns<{
+  name: TTableName
+  schema: undefined
+  columns: BuildColumns<
+    TTableName,
+    JsonSchemaToDrizzleColumns<TObjectType, TSchema, TPrimaryKey> & TColumnsMap,
+    'sqlite'
+  >
+  dialect: 'sqlite'
+}>
+
+/**
+ * Convert a JSONSchema Object Schema to a Drizzle Columns map (e.g. parameter
+ * for `sqliteTable()`). All top-level properties map to SQLite columns, with
+ * `required` properties marked as `NOT NULL`, and JSONSchema `default` will map
+ * to SQLite defaults.
+ *
+ * Any properties that are of type `object` or `array` in the JSONSchema will be
+ * mapped to a text field, which drizzle will parse and stringify. Types for
+ * `object` and `array` properties will be derived from `TObjectType`.
+ */
+type JsonSchemaToDrizzleColumns<
+  TObjectType extends { [K in keyof TSchema['properties']]?: any },
+  TSchema extends JSONSchema7Object,
+  TPrimaryKey extends keyof TSchema['properties'] | undefined = undefined
+> = AddJSONSchemaDefaults<
+  TSchema,
+  AddJSONSchemaRequired<
+    TSchema,
+    SchemaToDrizzleColumnsBase<TSchema, TObjectType>
+  >
+>
+
 /** Get the type of a JSONSchema string: array of constants for an enum,
 otherwise string[]. Strangeness is to convert it into the format expected by
 drizzle, which results in the correct type for the field from SQLite */
@@ -111,13 +96,12 @@ type Enum<
   : [string, ...string[]]
 
 /** True if JSONSchema object has a default */
-type HasDefault<T extends JSONSchema7> = T['default'] extends JSONSchema7Type
-  ? true
-  : false
+type HasJSONSchemaDefault<T extends JSONSchema7> =
+  T['default'] extends JSONSchema7Type ? true : false
 
 /** True if JSONSchema value is required */
-type IsRequired<
-  T extends JSONSchema7WithProps,
+type IsJSONSchemaRequired<
+  T extends JSONSchema7Object,
   U extends string,
   V extends JSONSchema7['required'] = T['required']
 > = V extends readonly any[] ? Includes<V, U> : false
@@ -131,23 +115,78 @@ type IsRequired<
  * stringify. Types for parsed JSON will be derived from MapeoDoc types.
  */
 export type SchemaToDrizzleColumns<
-  T extends JSONSchema7WithProps,
+  TSchema extends JSONSchema7Object,
+  /** This is the type matching the JSONSchema */
+  TObjectType extends { [K in keyof TSchema['properties']]?: any },
+  TPrimaryKey extends keyof TSchema['properties'] | undefined = undefined
+> = AddPrimaryKey<
+  AddJSONSchemaDefaults<
+    TSchema,
+    AddJSONSchemaRequired<
+      TSchema,
+      SchemaToDrizzleColumnsBase<TSchema, TObjectType>
+    >
+  >,
+  TPrimaryKey
+>
+
+/**
+ * Add `HasDefault` to columns if the JSONSchema has a default for that property
+ */
+type AddJSONSchemaDefaults<
+  TJSONSchema extends JSONSchema7Object,
+  TColumns extends Record<string, ColumnBuilderBase>,
+  U extends JsonSchema7Properties = TJSONSchema['properties']
+> = {
+  [K in keyof TColumns]: K extends keyof U
+    ? HasJSONSchemaDefault<U[K]> extends true
+      ? HasDefault<TColumns[K]>
+      : TColumns[K]
+    : TColumns[K]
+}
+
+/**
+ * Mark columns as NotNull if they are required in the JSONSchema
+ */
+type AddJSONSchemaRequired<
+  TJSONSchema extends JSONSchema7Object,
+  TColumns extends Record<string, ColumnBuilderBase>
+> = {
+  [K in keyof TColumns]: K extends string
+    ? IsJSONSchemaRequired<TJSONSchema, K> extends true
+      ? NotNull<TColumns[K]>
+      : TColumns[K]
+    : TColumns[K]
+}
+
+type AddPrimaryKey<
+  TColumns extends Record<string, ColumnBuilderBase>,
+  TKey extends keyof TColumns | undefined
+> = TKey extends string
+  ? Omit<TColumns, TKey> & { [K in TKey]: IsPrimaryKey<TColumns[TKey]> }
+  : TColumns
+
+/**
+ * Map JSONSchema object properties to Drizzle column types.
+ */
+type SchemaToDrizzleColumnsBase<
+  TSchema extends JSONSchema7Object,
   TObjectType extends { [K in keyof U]?: any },
-  U extends JsonSchema7Properties = T['properties']
+  U extends JsonSchema7Properties = TSchema['properties']
 > = {
   [K in keyof U]: K extends string
     ? U[K]['type'] extends 'string'
-      ? TextBuilder<K, Enum<U[K]>, IsRequired<T, K>, HasDefault<U[K]>>
+      ? SQLiteTextBuilder<Enum<U[K]>>
       : U[K]['type'] extends 'boolean'
-      ? BooleanBuilder<K, IsRequired<T, K>, HasDefault<U[K]>>
+      ? SQLiteBooleanBuilder
       : U[K]['type'] extends 'number'
-      ? RealBuilder<K, IsRequired<T, K>, HasDefault<U[K]>>
+      ? SQLiteRealBuilder
       : U[K]['type'] extends 'integer'
-      ? IntegerBuilder<K, IsRequired<T, K>, HasDefault<U[K]>>
+      ? SQLiteIntegerBuilder
       : U[K]['type'] extends 'array' | 'object'
-      ? JsonBuilder<K, TObjectType[K], IsRequired<T, K>, HasDefault<U[K]>>
+      ? $Type<SQLiteTextJsonBuilder, TObjectType[K]>
       : never
     : never
-} & { forks: JsonBuilder<'forks', string[], true, false> }
+} & { forks: $Type<SQLiteTextJsonBuilder, string[]> }
 
 export type NonEmptyArray<T> = [T, ...T[]]

package/src/translation-api.js

@@ -1,9 +1,11 @@
-import { and, sql } from 'drizzle-orm'
+import { and, eq, inArray, sql } from 'drizzle-orm'
 import { kCreateWithDocId, kSelect } from './datatype/index.js'
 import { deNullify, hashObject } from './utils.js'
 import { nullIfNotFound } from './errors.js'
 import { omit } from './lib/omit.js'
-/** @import { Translation, TranslationValue } from '@comapeo/schema' */
+import { iso6391To6393, iso6393To6391 } from './intl/iso639.js'
+import { translationTable } from './schema/project.js'
+/** @import { MapeoDoc, Translation, TranslationValue } from '@comapeo/schema' */
 /** @import { SetOptional } from 'type-fest' */
 
 export const ktranslatedLanguageCodeToSchemaNames = Symbol(
@@ -14,6 +16,9 @@ export default class TranslationApi {
    * TranslationValue['languageCode'],
    * Set<import('@comapeo/schema/dist/types.js').SchemaName>>} */
   #translatedLanguageCodeToSchemaNames = new Map()
+  // A bug in previous versions meant that translations were stored with ISO
+  // 639-1 codes, so we need to handle backwards compatibility for that case.
+  #hasLegacyIso6391Translations = false
   #dataType
   #indexPromise
 
@@ -69,19 +74,48 @@ export default class TranslationApi {
   async get(value) {
     await this.ready()
 
-    const docTypeIsTranslatedToLanguage =
-      this.#translatedLanguageCodeToSchemaNames
-        .get(value.languageCode)
-        ?.has(
-          /** @type {import('@comapeo/schema/dist/types.js').SchemaName} */ (
-            value.docRefType
-          )
+    // Allow this API to accept both ISO 639-1 and ISO 639-3 codes for languageCode
+    const normalizedLanguageCode =
+      value.languageCode.length === 2
+        ? iso6391To6393.get(value.languageCode)
+        : value.languageCode
+    if (!normalizedLanguageCode) return [] // invalid language code
+
+    const languageCodesToQuery = [normalizedLanguageCode]
+
+    // A bug in previous versions meant that translations could be stored with
+    // ISO 639-1 codes, so we need to query for both in this case by looking up
+    // the ISO 639-1 code for the langauge, and then checking whether there are
+    // translations for that language (looking up in our in-memory index saves
+    // an extra sqlite query when unnecessary)
+    if (this.#hasLegacyIso6391Translations) {
+      const iso6391LanguageCode =
+        value.languageCode.length === 2
+          ? value.languageCode
+          : iso6393To6391.get(value.languageCode)
+      const isTranslationStoredWithIso6391Code =
+        iso6391LanguageCode &&
+        this.#isTranslated(
+          /** @type {MapeoDoc['schemaName']} */
+          (value.docRefType),
+          iso6391LanguageCode
         )
+      if (isTranslationStoredWithIso6391Code) {
+        languageCodesToQuery.push(iso6391LanguageCode)
+      }
+    }
+
+    const docTypeIsTranslatedToLanguage =
+      this.#isTranslated(
+        /** @type {MapeoDoc['schemaName']} */
+        (value.docRefType),
+        normalizedLanguageCode
+      ) || languageCodesToQuery.length > 1
     if (!docTypeIsTranslatedToLanguage) return []
 
     const filters = [
-      sql`docRefType = ${value.docRefType}`,
-      sql`languageCode = ${value.languageCode}`,
+      eq(translationTable.docRefType, value.docRefType),
+      inArray(translationTable.languageCode, languageCodesToQuery),
       sql`json_extract(docRef, '$.docId') = ${value.docRef.docId}`,
     ]
 
@@ -94,7 +128,9 @@ export default class TranslationApi {
       filters.push(sql`propertyRef = ${value.propertyRef}`)
     }
     if (value.regionCode) {
-      filters.push(sql`regionCode = ${value.regionCode}`)
+      // Use COLLATE NOCASE for case-insensitive matching because in previous
+      // versions we did not normalize regionCode to uppercase.
+      filters.push(sql`regionCode = ${value.regionCode} COLLATE NOCASE`)
     }
 
     return (await this.#dataType[kSelect]())
@@ -118,6 +154,9 @@ export default class TranslationApi {
         translatedSchemas
       )
     }
+    if (doc.languageCode.length === 2) {
+      this.#hasLegacyIso6391Translations = true
+    }
     translatedSchemas.add(
       /** @type {import('@comapeo/schema/dist/types.js').SchemaName} */ (
         doc.docRefType
@@ -125,6 +164,19 @@ export default class TranslationApi {
     )
   }
 
+  /**
+   * @param {MapeoDoc['schemaName']} docType
+   * @param {string} languageCode
+   * @returns {boolean}
+   */
+  #isTranslated(docType, languageCode) {
+    return (
+      this.#translatedLanguageCodeToSchemaNames
+        .get(languageCode)
+        ?.has(docType) || false
+    )
+  }
+
   // This should only be used by tests.
   get [ktranslatedLanguageCodeToSchemaNames]() {
     return this.#translatedLanguageCodeToSchemaNames

package/src/utils.js

@@ -240,3 +240,16 @@ export function buildBlobId(attachment, requestedVariant) {
     driveId: attachment.driveDiscoveryId,
   }
 }
+
+/**
+ * Get typed entries from an object. Use this only on objects that you are
+ * certain have no extra properties - TS does not check for extra properties on
+ * an object, which is why Object.entries is untyped by default.
+ *
+ * @template {Record<string, unknown>} T
+ * @param {T} obj - The object to get entries from (must _not_ have extra properties)
+ * @returns {import('type-fest').Entries<T>}
+ */
+export function typedEntries(obj) {
+  return /** @type {import('type-fest').Entries<T>} */ (Object.entries(obj))
+}

package/dist/config-import.d.ts

@@ -1,74 +0,0 @@
-/**
- * @typedef {yauzl.Entry} Entry
- */
-/**
- * @typedef {{
- *   presets: { [id: string]: unknown }
- *   fields:  { [id: string]: unknown }
- * }} PresetsFile
- */
-/** @typedef {('presets' | 'fields')} ValidDocTypes */
-/**
- * @typedef {{
- *  [lang: string]: unknown
- * }} TranslationsFile
- */
-/** @typedef {NonNullable<import('@comapeo/schema').ProjectSettingsValue['configMetadata']>} MetadataFile */
-/**
- * @typedef {Parameters<import('./icon-api.js').IconApi['create']>[0]} IconData
- */
-/**
- * @param {string} configPath
- */
-export function readConfig(configPath: string): Promise<{
-    readonly warnings: Error[];
-    readonly metadata: {
-        importDate: string;
-        name: string;
-        buildDate: string;
-        fileVersion: string;
-    };
-    close(): Promise<void>;
-    /**
-     * @returns {AsyncIterable<IconData>}
-     */
-    icons(): AsyncIterable<IconData>;
-    /**
-     * @returns {Iterable<{ name: string, value: import('@comapeo/schema').FieldValue }>}
-     */
-    fields(): Iterable<{
-        name: string;
-        value: import("@comapeo/schema").FieldValue;
-    }>;
-    /**
-     * @returns {Iterable<{ fieldNames: string[], iconName: string | undefined, value: import('@comapeo/schema').PresetValue, name: string}>}
-     */
-    presets(): Iterable<{
-        fieldNames: string[];
-        iconName: string | undefined;
-        value: import("@comapeo/schema").PresetValue;
-        name: string;
-    }>;
-    /** @returns {Iterable<{ name: string, value:Omit<import('@comapeo/schema').TranslationValue, 'docRef'>}>} */
-    translations(): Iterable<{
-        name: string;
-        value: Omit<import("@comapeo/schema").TranslationValue, "docRef">;
-    }>;
-}>;
-export type Entry = yauzl.Entry;
-export type PresetsFile = {
-    presets: {
-        [id: string]: unknown;
-    };
-    fields: {
-        [id: string]: unknown;
-    };
-};
-export type ValidDocTypes = ("presets" | "fields");
-export type TranslationsFile = {
-    [lang: string]: unknown;
-};
-export type MetadataFile = NonNullable<import("@comapeo/schema").ProjectSettingsValue["configMetadata"]>;
-export type IconData = Parameters<import("./icon-api.js").IconApi["create"]>[0];
-import yauzl from 'yauzl-promise';
-//# sourceMappingURL=config-import.d.ts.map

package/dist/config-import.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config-import.d.ts","sourceRoot":"","sources":["../src/config-import.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;;;;;GAKG;AAEH,sDAAsD;AACtD;;;;GAIG;AAEH,4GAA4G;AAE5G;;GAEG;AAEH;;GAEG;AACH,uCAFW,MAAM;;;;;;;;;IAmCb;;OAEG;aADU,aAAa,CAAC,QAAQ,CAAC;IAiDpC;;OAEG;cADU,QAAQ,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,iBAAiB,EAAE,UAAU,CAAA;KAAE,CAAC;IA6BpF;;OAEG;eADU,QAAQ,CAAC;QAAE,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,KAAK,EAAE,OAAO,iBAAiB,EAAE,WAAW,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;IAiFxI,6GAA6G;oBAA/F,QAAQ,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAC,IAAI,CAAC,OAAO,iBAAiB,EAAE,gBAAgB,EAAE,QAAQ,CAAC,CAAA;KAAC,CAAC;GAkB5G;oBA9OY,KAAK,CAAC,KAAK;0BAGX;IACR,OAAO,EAAE;QAAE,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;IAClC,MAAM,EAAG;QAAE,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAA;CACnC;4BAGU,CAAC,SAAS,GAAG,QAAQ,CAAC;+BAEvB;IACZ,CAAI,IAAI,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;2BAGU,WAAW,CAAC,OAAO,iBAAiB,EAAE,oBAAoB,CAAC,gBAAgB,CAAC,CAAC;uBAG9E,UAAU,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;kBAjCnD,eAAe"}

package/dist/schema/schema-to-drizzle.d.ts

@@ -1,20 +0,0 @@
-/** @import { MapeoDoc } from '@comapeo/schema' */
-/** @import { MapeoDocMap } from '../types.js' */
-/**
-Convert a JSONSchema definition to a Drizzle Columns Map (the parameter for
-`sqliteTable()`).
-
-**NOTE**: The return of this function is _not_ type-checked (it is coerced with
-`as`, because it's not possible to type-check what this function is doing), but
-the return type _should_ be correct when using this function.
-@template {import('./types.js').JSONSchema7WithProps} TSchema
-NB: The inline typescript checker often marks this next line as an error, but this seems to be a bug with JSDoc parsing - running `tsc` does not show this as an error.
-@template {import('type-fest').Get<TSchema, 'properties.schemaName.const'>} TSchemaName
-@template {TSchemaName extends MapeoDoc['schemaName'] ? MapeoDocMap[TSchemaName] : any} TObjectType
-@param {TSchema} schema
-@returns {import('./types.js').SchemaToDrizzleColumns<TSchema, TObjectType>}
- */
-export function jsonSchemaToDrizzleColumns<TSchema extends import("./types.js").JSONSchema7WithProps, TSchemaName extends import("type-fest").Get<TSchema, "properties.schemaName.const">, TObjectType extends TSchemaName extends MapeoDoc["schemaName"] ? MapeoDocMap[TSchemaName] : any>(schema: TSchema): import("./types.js").SchemaToDrizzleColumns<TSchema, TObjectType>;
-import type { MapeoDoc } from '@comapeo/schema';
-import type { MapeoDocMap } from '../types.js';
-//# sourceMappingURL=schema-to-drizzle.d.ts.map

package/dist/schema/schema-to-drizzle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-to-drizzle.d.ts","sourceRoot":"","sources":["../../src/schema/schema-to-drizzle.js"],"names":[],"mappings":"AAGA,kDAAkD;AAClD,iDAAiD;AAEjD;;;;;;;;;;;;;GAaG;AACH,2CAPsD,OAAO,SAAnD,OAAQ,YAAY,EAAE,oBAAqB,EAEuB,WAAW,SAA7E,OAAQ,WAAW,EAAE,GAAG,CAAC,OAAO,EAAE,6BAA6B,CAAE,EACa,WAAW,SAAxF,WAAW,SAAS,QAAQ,CAAC,YAAY,CAAC,GAAG,WAAW,CAAC,WAAW,CAAC,GAAG,GAAI,UAC/E,OAAO,GACL,OAAO,YAAY,EAAE,sBAAsB,CAAC,OAAO,EAAE,WAAW,CAAC,CAyD1E;8BAxE6B,iBAAiB;iCACd,aAAa"}

package/dist/schema/utils.d.ts

@@ -1,55 +0,0 @@
-/**
- * Table for storing backlinks, used for indexing. There needs to be one for
- * each indexed document type
- * @param {SqliteTable} tableSchema
- */
-export function backlinkTable(tableSchema: SqliteTable): SQLiteTableWithColumns<{
-    name: string;
-    schema: undefined;
-    columns: {
-        versionId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
-            name: "versionId";
-            tableName: string;
-            dataType: "string";
-            columnType: "SQLiteText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-        }, object>;
-    };
-    dialect: "sqlite";
-}>;
-/**
- * @param {string} tableName
- */
-export function getBacklinkTableName(tableName: string): string;
-/** @import { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core' */
-/**
- * @template {string} [TName=string]
- * @typedef {SQLiteTableWithColumns<{
- *   name: TName;
- *   dialect: 'sqlite';
- *   schema: string | undefined;
- *   columns: any
- * }>} SqliteTable
- */
-export const BACKLINK_TABLE_POSTFIX: "_backlink";
-export const customJson: <TName extends string>(dbName: TName, fieldConfig?: unknown) => import("drizzle-orm/sqlite-core").SQLiteCustomColumnBuilder<{
-    name: TName;
-    dataType: "custom";
-    columnType: "SQLiteCustomColumn";
-    data: unknown;
-    driverParam: unknown;
-    enumValues: undefined;
-}>;
-export type SqliteTable<TName extends string = string> = SQLiteTableWithColumns<{
-    name: TName;
-    dialect: "sqlite";
-    schema: string | undefined;
-    columns: any;
-}>;
-import type { SQLiteTableWithColumns } from 'drizzle-orm/sqlite-core';
-//# sourceMappingURL=utils.d.ts.map

package/dist/schema/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/schema/utils.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,2CAFW,WAAW;;;;;;;;;;;;;;;;;;GAOrB;AAED;;GAEG;AACH,gDAFW,MAAM,UAIhB;AA/BD,wEAAwE;AAExE;;;;;;;;GAQG;AAEH,iDAAiD;AAqBjD;;;;;;;GAWE;wBAzCqB,KAAK,SAAf,MAAQ,aACR,uBAAuB;IAC/B,IAAI,EAAE,KAAK,CAAC;IACZ,OAAO,EAAE,QAAQ,CAAC;IAClB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,OAAO,EAAE,GAAG,CAAA;CACb,CAAC;4CATuC,yBAAyB"}