@livestore/common 0.3.1 → 0.3.2-dev.1

package/src/schema/state/sqlite/query-builder/impl.ts

@@ -1,20 +1,19 @@
+/** biome-ignore-all lint/complexity/noArguments: using arguments is fine here */
 import { casesHandled, shouldNeverHappen } from '@livestore/utils'
 import { Match, Option, Predicate, Schema } from '@livestore/utils/effect'
 
-import type { TableDefBase } from '../table-def.js'
-import type { QueryBuilder, QueryBuilderAst } from './api.js'
-import { QueryBuilderAstSymbol, QueryBuilderTypeId } from './api.js'
-import { astToSql } from './astToSql.js'
+import type { TableDefBase } from '../table-def.ts'
+import type { QueryBuilder, QueryBuilderAst } from './api.ts'
+import { QueryBuilderAstSymbol, QueryBuilderTypeId } from './api.ts'
+import { astToSql } from './astToSql.ts'
 export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
   tableDef: TTableDef,
   ast: QueryBuilderAst = emptyAst(tableDef),
 ): QueryBuilder<TResult, TTableDef, never> => {
   const api = {
-    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
     select() {
       assertSelectQueryBuilderAst(ast)
 
-      // eslint-disable-next-line prefer-rest-params
       const params = [...arguments]
 
       // Pluck if there's only one column selected
@@ -36,13 +35,12 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
         select: { columns },
       }) as any
     },
-    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+    // biome-ignore lint/complexity/useArrowFunction: prefer function over arrow function for this case
     where: function () {
       if (ast._tag === 'InsertQuery') return invalidQueryBuilder('Cannot use where with insert')
       if (ast._tag === 'RowQuery') return invalidQueryBuilder('Cannot use where with row')
 
       if (arguments.length === 1) {
-        // eslint-disable-next-line prefer-rest-params
         const params = arguments[0]
         const newOps = Object.entries(params)
           .filter(([, value]) => value !== undefined)
@@ -68,7 +66,6 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
         }
       }
 
-      // eslint-disable-next-line prefer-rest-params
       const [col, opOrValue, valueOrUndefined] = arguments
       const op = valueOrUndefined === undefined ? '=' : opOrValue
       const value = valueOrUndefined === undefined ? opOrValue : valueOrUndefined
@@ -88,14 +85,13 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
         }
       }
     },
-    // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+
     orderBy() {
       assertSelectQueryBuilderAst(ast)
 
       if (arguments.length === 0 || arguments.length > 2) return invalidQueryBuilder()
 
       if (arguments.length === 1) {
-        // eslint-disable-next-line prefer-rest-params
         const params = arguments[0] as QueryBuilder.OrderByParams<TTableDef>
         return makeQueryBuilder(tableDef, {
           ...ast,
@@ -103,7 +99,6 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
         })
       }
 
-      // eslint-disable-next-line prefer-rest-params
       const [col, direction] = arguments as any as [keyof TTableDef['sqliteDef']['columns'] & string, 'asc' | 'desc']
 
       return makeQueryBuilder(tableDef, {
@@ -136,7 +131,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
         ),
       })
     },
-    first: (options) => {
+    first: (behaviour) => {
       assertSelectQueryBuilderAst(ast)
 
       if (ast.limit._tag === 'Some') return invalidQueryBuilder(`.first() can't be called after .limit()`)
@@ -144,17 +139,16 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
       return makeQueryBuilder(tableDef, {
         ...ast,
         limit: Option.some(1),
-        pickFirst:
-          options?.fallback !== undefined && options.fallback !== 'throws' ? { fallback: options.fallback } : 'throws',
+        pickFirst: { _tag: 'enabled', ...(behaviour ?? { behaviour: 'undefined' }) },
       })
     },
-    // // eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+    //
     // getOrCreate() {
     //   if (tableDef.options.isClientDocumentTable === false) {
     //     return invalidQueryBuilder(`getOrCreate() is not allowed when table is not a client document table`)
     //   }
 
-    //   // eslint-disable-next-line prefer-rest-params
+    //
     //   const params = [...arguments]
 
     //   let id: string | number
@@ -249,7 +243,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
   return {
     [QueryBuilderTypeId]: QueryBuilderTypeId,
     [QueryBuilderAstSymbol]: ast,
-    ['ResultType']: 'only-for-type-inference' as TResult,
+    ResultType: 'only-for-type-inference' as TResult,
     asSql: () => astToSql(ast),
     toString: () => {
       try {
@@ -266,7 +260,7 @@ export const makeQueryBuilder = <TResult, TTableDef extends TableDefBase>(
 const emptyAst = (tableDef: TableDefBase): QueryBuilderAst.SelectQuery => ({
   _tag: 'SelectQuery',
   columns: [],
-  pickFirst: false,
+  pickFirst: { _tag: 'disabled' },
   select: { columns: [] },
   orderBy: [],
   offset: Option.none(),
@@ -277,31 +271,29 @@ const emptyAst = (tableDef: TableDefBase): QueryBuilderAst.SelectQuery => ({
 })
 
 // Helper functions
-// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
+
 function assertSelectQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.SelectQuery {
   if (ast._tag !== 'SelectQuery') {
-    return shouldNeverHappen('Expected SelectQuery but got ' + ast._tag)
+    return shouldNeverHappen(`Expected SelectQuery but got ${ast._tag}`)
   }
 }
 
-// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
 function assertInsertQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.InsertQuery {
   if (ast._tag !== 'InsertQuery') {
-    return shouldNeverHappen('Expected InsertQuery but got ' + ast._tag)
+    return shouldNeverHappen(`Expected InsertQuery but got ${ast._tag}`)
   }
 }
 
-// eslint-disable-next-line prefer-arrow/prefer-arrow-functions
 function assertWriteQueryBuilderAst(ast: QueryBuilderAst): asserts ast is QueryBuilderAst.WriteQuery {
   if (ast._tag !== 'InsertQuery' && ast._tag !== 'UpdateQuery' && ast._tag !== 'DeleteQuery') {
-    return shouldNeverHappen('Expected WriteQuery but got ' + ast._tag)
+    return shouldNeverHappen(`Expected WriteQuery but got ${ast._tag}`)
   }
 }
 
 const isRowQuery = (ast: QueryBuilderAst): ast is QueryBuilderAst.RowQuery => ast._tag === 'RowQuery'
 
 export const invalidQueryBuilder = (msg?: string) => {
-  return shouldNeverHappen('Invalid query builder' + (msg ? `: ${msg}` : ''))
+  return shouldNeverHappen(`Invalid query builder${msg ? `: ${msg}` : ''}`)
 }
 
 export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<any> => {
@@ -309,9 +301,12 @@ export const getResultSchema = (qb: QueryBuilder<any, any, any>): Schema.Schema<
   switch (queryAst._tag) {
     case 'SelectQuery': {
       const arraySchema = Schema.Array(queryAst.resultSchemaSingle)
-      if (queryAst.pickFirst === false) {
+      if (queryAst.pickFirst._tag === 'disabled') {
         return arraySchema
-      } else if (queryAst.pickFirst === 'throws') {
+      } else if (queryAst.pickFirst.behaviour === 'undefined') {
+        const arraySchema = Schema.Array(Schema.UndefinedOr(queryAst.resultSchemaSingle))
+        return arraySchema.pipe(Schema.headOrElse(() => undefined))
+      } else if (queryAst.pickFirst.behaviour === 'error') {
         // Will throw if the array is empty
         return arraySchema.pipe(Schema.headOrElse())
       } else {

package/src/schema/state/sqlite/query-builder/mod.ts

@@ -1,5 +1,5 @@
-export * from './api.js'
-export * from './impl.js'
+export * from './api.ts'
+export * from './impl.ts'
 
 /**
  * Design decisions:

package/src/schema/state/sqlite/schema-helpers.ts

@@ -1,8 +1,8 @@
 import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyRecord, Schema } from '@livestore/utils/effect'
 
-import { SqliteDsl } from './db-schema/mod.js'
-import type { TableDef, TableDefBase } from './table-def.js'
+import { SqliteDsl } from './db-schema/mod.ts'
+import type { TableDef, TableDefBase } from './table-def.ts'
 
 export const getDefaultValuesEncoded = <TTableDef extends TableDef>(
   tableDef: TTableDef,

package/src/schema/state/sqlite/system-tables.ts

@@ -1,10 +1,10 @@
 import { Schema } from '@livestore/utils/effect'
 
-import * as EventSequenceNumber from '../../EventSequenceNumber.js'
-import { SqliteDsl } from './db-schema/mod.js'
-import { table } from './table-def.js'
+import * as EventSequenceNumber from '../../EventSequenceNumber.ts'
+import { SqliteDsl } from './db-schema/mod.ts'
+import { table } from './table-def.ts'
 
-/// Read model DB
+/// State DB
 
 export const SCHEMA_META_TABLE = '__livestore_schema'
 
@@ -46,6 +46,7 @@ export const sessionChangesetMetaTable = table({
     // TODO bring back primary key
     seqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
     seqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    seqNumRebaseGeneration: SqliteDsl.integer({}),
     changeset: SqliteDsl.blob({ nullable: true }),
     debug: SqliteDsl.json({ nullable: true }),
   },
@@ -54,25 +55,7 @@ export const sessionChangesetMetaTable = table({
 
 export type SessionChangesetMetaRow = typeof sessionChangesetMetaTable.Type
 
-export const LEADER_MERGE_COUNTER_TABLE = '__livestore_leader_merge_counter'
-
-// TODO get rid of this table in favour of client-only merge generation
-export const leaderMergeCounterTable = table({
-  name: LEADER_MERGE_COUNTER_TABLE,
-  columns: {
-    id: SqliteDsl.integer({ primaryKey: true, schema: Schema.Literal(0) }),
-    mergeCounter: SqliteDsl.integer({ primaryKey: true }),
-  },
-})
-
-export type LeaderMergeCounterRow = typeof leaderMergeCounterTable.Type
-
-export const stateSystemTables = [
-  schemaMetaTable,
-  schemaEventDefsMetaTable,
-  sessionChangesetMetaTable,
-  leaderMergeCounterTable,
-]
+export const stateSystemTables = [schemaMetaTable, schemaEventDefsMetaTable, sessionChangesetMetaTable] as const
 
 export const isStateSystemTable = (tableName: string) => stateSystemTables.some((_) => _.sqliteDef.name === tableName)
 
@@ -86,8 +69,11 @@ export const eventlogMetaTable = table({
     // TODO Adjust modeling so a global event never needs a client id component
     seqNumGlobal: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.GlobalEventSequenceNumber }),
     seqNumClient: SqliteDsl.integer({ primaryKey: true, schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    seqNumRebaseGeneration: SqliteDsl.integer({ primaryKey: true }),
     parentSeqNumGlobal: SqliteDsl.integer({ schema: EventSequenceNumber.GlobalEventSequenceNumber }),
     parentSeqNumClient: SqliteDsl.integer({ schema: EventSequenceNumber.ClientEventSequenceNumber }),
+    parentSeqNumRebaseGeneration: SqliteDsl.integer({}),
+    /** Event definition name */
     name: SqliteDsl.text({}),
     argsJson: SqliteDsl.text({ schema: Schema.parseJson(Schema.Any) }),
     clientId: SqliteDsl.text({}),
@@ -97,7 +83,7 @@ export const eventlogMetaTable = table({
   },
   indexes: [
     { columns: ['seqNumGlobal'], name: 'idx_eventlog_seqNumGlobal' },
-    { columns: ['seqNumGlobal', 'seqNumClient'], name: 'idx_eventlog_seqNum' },
+    { columns: ['seqNumGlobal', 'seqNumClient', 'seqNumRebaseGeneration'], name: 'idx_eventlog_seqNum' },
   ],
 })
 
@@ -105,6 +91,7 @@ export type EventlogMetaRow = typeof eventlogMetaTable.Type
 
 export const SYNC_STATUS_TABLE = '__livestore_sync_status'
 
+// TODO support sync backend identity (to detect if sync backend changes)
 export const syncStatusTable = table({
   name: SYNC_STATUS_TABLE,
   columns: {
@@ -114,4 +101,4 @@ export const syncStatusTable = table({
 
 export type SyncStatusRow = typeof syncStatusTable.Type
 
-export const eventlogSystemTables = [eventlogMetaTable, syncStatusTable]
+export const eventlogSystemTables = [eventlogMetaTable, syncStatusTable] as const

package/src/schema/state/sqlite/table-def.ts

@@ -1,9 +1,9 @@
-import { type Nullable } from '@livestore/utils'
+import type { Nullable } from '@livestore/utils'
 import type { Schema, Types } from '@livestore/utils/effect'
 
-import { SqliteDsl } from './db-schema/mod.js'
-import type { QueryBuilder } from './query-builder/mod.js'
-import { makeQueryBuilder, QueryBuilderAstSymbol, QueryBuilderTypeId } from './query-builder/mod.js'
+import { SqliteDsl } from './db-schema/mod.ts'
+import type { QueryBuilder } from './query-builder/mod.ts'
+import { makeQueryBuilder, QueryBuilderAstSymbol, QueryBuilderTypeId } from './query-builder/mod.ts'
 
 export const { blob, boolean, column, datetime, integer, isColumnDefinition, json, real, text } = SqliteDsl
 

package/src/schema-management/common.ts

@@ -1,6 +1,6 @@
-import type { SqliteDb } from '../adapter-types.js'
-import type { ParamsObject } from '../util.js'
-import { prepareBindValues } from '../util.js'
+import type { SqliteDb } from '../adapter-types.ts'
+import type { ParamsObject } from '../util.ts'
+import { prepareBindValues } from '../util.ts'
 
 // TODO bring back statement caching
 // will require proper scope-aware cleanup etc (for testing and apps with multiple LiveStore instances)

package/src/schema-management/migrations.ts

@@ -1,21 +1,23 @@
 import { memoizeByStringifyArgs } from '@livestore/utils'
 import { Effect, Schema as EffectSchema } from '@livestore/utils/effect'
 
-import type { MigrationsReport, MigrationsReportEntry, SqliteDb, UnexpectedError } from '../adapter-types.js'
-import type { LiveStoreSchema } from '../schema/mod.js'
-import { SqliteAst, SqliteDsl } from '../schema/state/sqlite/db-schema/mod.js'
-import type { SchemaEventDefsMetaRow, SchemaMetaRow } from '../schema/state/sqlite/system-tables.js'
+import type { SqliteDb } from '../adapter-types.ts'
+import type { MigrationsReport, MigrationsReportEntry } from '../defs.ts'
+import type { UnexpectedError } from '../errors.ts'
+import type { LiveStoreSchema } from '../schema/mod.ts'
+import { SqliteAst, SqliteDsl } from '../schema/state/sqlite/db-schema/mod.ts'
+import type { SchemaEventDefsMetaRow, SchemaMetaRow } from '../schema/state/sqlite/system-tables.ts'
 import {
   isStateSystemTable,
   SCHEMA_EVENT_DEFS_META_TABLE,
   SCHEMA_META_TABLE,
   schemaEventDefsMetaTable,
   stateSystemTables,
-} from '../schema/state/sqlite/system-tables.js'
-import { sql } from '../util.js'
-import type { SchemaManager } from './common.js'
-import { dbExecute, dbSelect } from './common.js'
-import { validateSchema } from './validate-schema.js'
+} from '../schema/state/sqlite/system-tables.ts'
+import { sql } from '../util.ts'
+import type { SchemaManager } from './common.ts'
+import { dbExecute, dbSelect } from './common.ts'
+import { validateSchema } from './validate-schema.ts'
 
 const getMemoizedTimestamp = memoizeByStringifyArgs(() => new Date().toISOString())
 

package/src/schema-management/validate-schema.ts

@@ -1,9 +1,9 @@
 import { Effect, Schema } from '@livestore/utils/effect'
 
-import { UnexpectedError } from '../adapter-types.js'
-import type { EventDef } from '../schema/EventDef.js'
-import type { LiveStoreSchema } from '../schema/mod.js'
-import type { EventDefInfo, SchemaManager } from './common.js'
+import { UnexpectedError } from '../adapter-types.ts'
+import type { EventDef } from '../schema/EventDef.ts'
+import type { LiveStoreSchema } from '../schema/mod.ts'
+import type { EventDefInfo, SchemaManager } from './common.ts'
 
 export const validateSchema = (schema: LiveStoreSchema, schemaManager: SchemaManager) =>
   Effect.gen(function* () {

package/src/sql-queries/index.ts

@@ -1,3 +1,3 @@
-export * from './sql-queries.js'
-export * from './sql-query-builder.js'
-export * from './types.js'
+export * from './sql-queries.ts'
+export * from './sql-query-builder.ts'
+export * from './types.ts'

package/src/sql-queries/sql-queries.ts

@@ -1,10 +1,10 @@
 import { shouldNeverHappen } from '@livestore/utils'
 import { pipe, ReadonlyArray, Schema, TreeFormatter } from '@livestore/utils/effect'
 
-import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.js'
-import { sql } from '../util.js'
-import { objectEntries } from './misc.js'
-import * as ClientTypes from './types.js'
+import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.ts'
+import { sql } from '../util.ts'
+import { objectEntries } from './misc.ts'
+import * as ClientTypes from './types.ts'
 
 export type BindValues = {
   readonly [columnName: string]: any
@@ -106,6 +106,7 @@ export const insertRows = <TColumns extends SqliteDsl.Columns>({
 
   const bindValues = valuesArray.reduce(
     (acc, values, itemIndex) => ({
+      // biome-ignore lint/performance/noAccumulatingSpread: TODO improve this some day
       ...acc,
       ...makeBindValues({ columns, values, variablePrefix: `item_${itemIndex}_` }),
     }),
@@ -292,6 +293,7 @@ Error: ${parseErrorStr}
 Value:`,
             value,
           )
+          // biome-ignore lint/suspicious/noDebugger: debug
           debugger
           throw res.left
         } else {

package/src/sql-queries/sql-query-builder.ts

@@ -1,7 +1,7 @@
-import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.js'
-import type { BindValues } from './sql-queries.js'
-import * as SqlQueries from './sql-queries.js'
-import type * as ClientTypes from './types.js'
+import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.ts'
+import type { BindValues } from './sql-queries.ts'
+import * as SqlQueries from './sql-queries.ts'
+import type * as ClientTypes from './types.ts'
 
 export type SqlQuery = [stmt: string, bindValues: BindValues, tableName: string]
 

package/src/sql-queries/types.ts

@@ -1,7 +1,7 @@
 import type { Prettify } from '@livestore/utils'
 import type { Schema } from '@livestore/utils/effect'
 
-import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.js'
+import type { SqliteDsl } from '../schema/state/sqlite/db-schema/mod.ts'
 
 export type DecodedValuesForTableAll<TSchema extends SqliteDsl.DbSchema, TTableName extends keyof TSchema> = {
   [K in keyof GetColumns<TSchema, TTableName>]: Schema.Schema.Type<GetColumn<TSchema, TTableName, K>['schema']>

package/src/sqlite-db-helper.ts

@@ -1,8 +1,8 @@
 import { Schema } from '@livestore/utils/effect'
 
-import type { SqliteDb } from './adapter-types.js'
-import { getResultSchema, isQueryBuilder } from './schema/state/sqlite/query-builder/mod.js'
-import type { PreparedBindValues } from './util.js'
+import type { SqliteDb } from './adapter-types.ts'
+import { getResultSchema, isQueryBuilder } from './schema/state/sqlite/query-builder/mod.ts'
+import type { PreparedBindValues } from './util.ts'
 
 export const makeExecute = (
   execute: (

package/src/sqlite-types.ts

@@ -0,0 +1,76 @@
+import { type Effect, Schema } from '@livestore/utils/effect'
+import type { SqliteError, UnexpectedError } from './errors.ts'
+import type { EventSequenceNumber } from './schema/mod.ts'
+import type { QueryBuilder } from './schema/state/sqlite/query-builder/api.ts'
+import type { PreparedBindValues } from './util.ts'
+
+/**
+ * Common interface for SQLite databases used by LiveStore to facilitate a consistent API across different platforms.
+ * Always assumes a synchronous SQLite build with the `bytecode` and `session` extensions enabled.
+ * Can be either in-memory or persisted to disk.
+ */
+export interface SqliteDb<TReq = any, TMetadata extends TReq = TReq> {
+  _tag: 'SqliteDb'
+  metadata: TMetadata
+  /** Debug information (currently not persisted and only available at runtime) */
+  debug: SqliteDebugInfo
+  prepare(queryStr: string): PreparedStatement
+  execute(
+    queryStr: string,
+    bindValues?: PreparedBindValues | undefined,
+    options?: { onRowsChanged?: (rowsChanged: number) => void },
+  ): void
+  execute(queryBuilder: QueryBuilder.Any, options?: { onRowsChanged?: (rowsChanged: number) => void }): void
+
+  select<T>(queryStr: string, bindValues?: PreparedBindValues | undefined): ReadonlyArray<T>
+  select<T>(queryBuilder: QueryBuilder<T, any, any>): T
+
+  export(): Uint8Array
+  import: (data: Uint8Array | SqliteDb<TReq>) => void
+  close(): void
+  destroy(): void
+  session(): SqliteDbSession
+  makeChangeset: (data: Uint8Array) => SqliteDbChangeset
+}
+
+export type SqliteDebugInfo = { head: EventSequenceNumber.EventSequenceNumber }
+
+// TODO refactor this helper type. It's quite cumbersome to use and should be revisited.
+export type MakeSqliteDb<
+  TReq = { dbPointer: number; persistenceInfo: PersistenceInfo },
+  TInput_ extends { _tag: string } = { _tag: string },
+  TMetadata_ extends TReq = TReq,
+  R = never,
+> = <
+  TInput extends TInput_,
+  TMetadata extends TMetadata_ & { _tag: TInput['_tag'] } = TMetadata_ & { _tag: TInput['_tag'] },
+>(
+  input: TInput,
+) => Effect.Effect<SqliteDb<TReq, Extract<TMetadata, { _tag: TInput['_tag'] }>>, SqliteError | UnexpectedError, R>
+
+export interface PreparedStatement {
+  execute(bindValues: PreparedBindValues | undefined, options?: { onRowsChanged?: (rowsChanged: number) => void }): void
+  select<T>(bindValues: PreparedBindValues | undefined): ReadonlyArray<T>
+  finalize(): void
+  sql: string
+}
+
+export type SqliteDbSession = {
+  changeset: () => Uint8Array | undefined
+  finish: () => void
+}
+
+export type SqliteDbChangeset = {
+  // TODO combining changesets (requires changes in the SQLite WASM binding)
+  invert: () => SqliteDbChangeset
+  apply: () => void
+}
+
+export const PersistenceInfo = Schema.Struct(
+  {
+    fileName: Schema.String,
+  },
+  { key: Schema.String, value: Schema.Any },
+).annotations({ title: 'LiveStore.PersistenceInfo' })
+
+export type PersistenceInfo<With extends {} = {}> = typeof PersistenceInfo.Type & With