@livestore/common 0.4.0-dev.6 → 0.4.0-dev.8

package/src/schema/state/sqlite/column-annotations.ts

@@ -1,5 +1,5 @@
 import type { Schema } from '@livestore/utils/effect'
-import { dual } from '@livestore/utils/effect'
+import { dual, Option, SchemaAST } from '@livestore/utils/effect'
 import type { SqliteDsl } from './db-schema/mod.ts'
 
 export const PrimaryKeyId = Symbol.for('livestore/state/sqlite/annotations/primary-key')
@@ -32,7 +32,7 @@ Here are the knobs you can turn per-column when you CREATE TABLE (or ALTER TABLE
  * Adds a primary key annotation to a schema.
  */
 export const withPrimaryKey = <T extends Schema.Schema.All>(schema: T) =>
-  schema.annotations({ [PrimaryKeyId]: true }) as T
+  applyAnnotations(schema, { [PrimaryKeyId]: true })
 
 /**
  * Adds a column type annotation to a schema.
@@ -43,19 +43,19 @@ export const withColumnType: {
   <T extends Schema.Schema.All>(schema: T, type: SqliteDsl.FieldColumnType): T
 } = dual(2, <T extends Schema.Schema.All>(schema: T, type: SqliteDsl.FieldColumnType) => {
   validateSchemaColumnTypeCompatibility(schema, type)
-  return schema.annotations({ [ColumnType]: type }) as T
+  return applyAnnotations(schema, { [ColumnType]: type })
 })
 
 /**
  * Adds an auto-increment annotation to a schema.
  */
 export const withAutoIncrement = <T extends Schema.Schema.All>(schema: T) =>
-  schema.annotations({ [AutoIncrement]: true }) as T
+  applyAnnotations(schema, { [AutoIncrement]: true })
 
 /**
  * Adds a unique constraint annotation to a schema.
  */
-export const withUnique = <T extends Schema.Schema.All>(schema: T) => schema.annotations({ [Unique]: true }) as T
+export const withUnique = <T extends Schema.Schema.All>(schema: T) => applyAnnotations(schema, { [Unique]: true })
 
 /**
  * Adds a default value annotation to a schema.
@@ -64,7 +64,7 @@ export const withDefault: {
   // TODO make type safe
   <T extends Schema.Schema.All>(schema: T, value: unknown): T
   (value: unknown): <T extends Schema.Schema.All>(schema: T) => T
-} = dual(2, <T extends Schema.Schema.All>(schema: T, value: unknown) => schema.annotations({ [Default]: value }) as T)
+} = dual(2, <T extends Schema.Schema.All>(schema: T, value: unknown) => applyAnnotations(schema, { [Default]: value }))
 
 /**
  * Validates that a schema is compatible with the specified SQLite column type
@@ -75,3 +75,13 @@ const validateSchemaColumnTypeCompatibility = (
 ): void => {
   // TODO actually implement this
 }
+
+const applyAnnotations = <T extends Schema.Schema.All>(schema: T, overrides: Record<PropertyKey, unknown>): T => {
+  const identifier = SchemaAST.getIdentifierAnnotation(schema.ast)
+  const shouldPreserveIdentifier = Option.isSome(identifier) && !(SchemaAST.IdentifierAnnotationId in overrides)
+  const annotations: Record<PropertyKey, unknown> = shouldPreserveIdentifier
+    ? { ...overrides, [SchemaAST.IdentifierAnnotationId]: identifier.value }
+    : overrides
+
+  return schema.annotations(annotations) as T
+}

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

@@ -683,6 +683,127 @@ describe('query builder', () => {
       expect(pattern1).toEqual(pattern2)
     })
   })
+
+  describe('schema transforms', () => {
+    const Flat = Schema.Struct({
+      id: Schema.String.pipe(State.SQLite.withPrimaryKey),
+      contactFirstName: Schema.String,
+      contactLastName: Schema.String,
+      contactEmail: Schema.String.pipe(State.SQLite.withUnique),
+    })
+
+    const Nested = Schema.transform(
+      Flat,
+      Schema.Struct({
+        id: Schema.String,
+        contact: Schema.Struct({
+          firstName: Schema.String,
+          lastName: Schema.String,
+          email: Schema.String,
+        }),
+      }),
+      {
+        decode: ({ id, contactFirstName, contactLastName, contactEmail }) => ({
+          id,
+          contact: {
+            firstName: contactFirstName,
+            lastName: contactLastName,
+            email: contactEmail,
+          },
+        }),
+        encode: ({ id, contact }) => ({
+          id,
+          contactFirstName: contact.firstName,
+          contactLastName: contact.lastName,
+          contactEmail: contact.email,
+        }),
+      },
+    )
+
+    const makeContactsTable = () =>
+      State.SQLite.table({
+        name: 'contacts',
+        schema: Nested,
+        // schema: Flat,
+      })
+
+    it('exposes flattened insert type while schema type is nested', () => {
+      const contactsTable = makeContactsTable()
+
+      type InsertInput = Parameters<(typeof contactsTable)['insert']>[0]
+      type NestedType = Schema.Schema.Type<typeof Nested>
+
+      type Assert<T extends true> = T
+
+      type InsertKeys = keyof InsertInput
+      type NestedKeys = keyof NestedType
+
+      type _InsertHasFlattenedColumns = Assert<
+        'contactFirstName' extends InsertKeys
+          ? 'contactLastName' extends InsertKeys
+            ? 'contactEmail' extends InsertKeys
+              ? true
+              : false
+            : false
+          : false
+      >
+
+      type _InsertDoesNotExposeNested = Assert<Extract<'contact', InsertKeys> extends never ? true : false>
+
+      type _SchemaTypeIsNested = Assert<'contact' extends NestedKeys ? true : false>
+
+      void contactsTable
+    })
+
+    it('fails to encode nested inserts because flat columns are required', () => {
+      const contactsTable = makeContactsTable()
+
+      expect(
+        contactsTable
+          // TODO in the future we should use decoded types here instead of encoded
+          .insert({
+            id: 'person-1',
+            contactFirstName: 'Ada',
+            contactLastName: 'Lovelace',
+            contactEmail: 'ada@example.com',
+          })
+          .asSql(),
+      ).toMatchInlineSnapshot(`
+        {
+          "bindValues": [
+            "person-1",
+            "Ada",
+            "Lovelace",
+            "ada@example.com",
+          ],
+          "query": "INSERT INTO 'contacts' (id, contactFirstName, contactLastName, contactEmail) VALUES (?, ?, ?, ?)",
+          "usedTables": Set {
+            "contacts",
+          },
+        }
+      `)
+    })
+
+    it('fails to encode nested inserts because flat columns are required', () => {
+      const contactsTable = makeContactsTable()
+
+      expect(() =>
+        contactsTable
+          .insert({
+            id: 'person-1',
+            // @ts-expect-error
+            contact: {
+              firstName: 'Ada',
+              lastName: 'Lovelace',
+              email: 'ada@example.com',
+            },
+          })
+          .asSql(),
+      ).toThrowErrorMatchingInlineSnapshot(`
+        [ParseError: contacts\n└─ ["contactFirstName"]\n   └─ is missing]
+      `)
+    })
+  })
 })
 
 // TODO nested queries

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

@@ -178,6 +178,59 @@ describe('table function overloads', () => {
     expect(userTable.sqliteDef.columns.age.columnType).toBe('integer')
   })
 
+  it('should support schemas that transform flat columns into nested types', () => {
+    const Flat = Schema.Struct({
+      id: Schema.String.pipe(State.SQLite.withPrimaryKey),
+      contactFirstName: Schema.String,
+      contactLastName: Schema.String,
+      contactEmail: Schema.String.pipe(State.SQLite.withUnique),
+    })
+
+    const Nested = Schema.transform(
+      Flat,
+      Schema.Struct({
+        id: Schema.String,
+        contact: Schema.Struct({
+          firstName: Schema.String,
+          lastName: Schema.String,
+          email: Schema.String,
+        }),
+      }),
+      {
+        decode: ({ id, contactFirstName, contactLastName, contactEmail }) => ({
+          id,
+          contact: {
+            firstName: contactFirstName,
+            lastName: contactLastName,
+            email: contactEmail,
+          },
+        }),
+        encode: ({ id, contact }) => ({
+          id,
+          contactFirstName: contact.firstName,
+          contactLastName: contact.lastName,
+          contactEmail: contact.email,
+        }),
+      },
+    )
+
+    const contactsTable = State.SQLite.table({
+      name: 'contacts',
+      schema: Nested,
+    })
+
+    const columns = contactsTable.sqliteDef.columns
+
+    expect(Object.keys(columns)).toEqual(['id', 'contactFirstName', 'contactLastName', 'contactEmail'])
+    expect(columns.id.primaryKey).toBe(true)
+    expect(columns.contactEmail.columnType).toBe('text')
+    expect(contactsTable.sqliteDef.indexes).toContainEqual({
+      name: 'idx_contacts_contactEmail_unique',
+      columns: ['contactEmail'],
+      isUnique: true,
+    })
+  })
+
   it('should extract table name from Schema.Class identifier', () => {
     class TodoItem extends Schema.Class<TodoItem>('TodoItem')({
       id: Schema.String,

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

@@ -1,5 +1,5 @@
 import { type Nullable, shouldNeverHappen } from '@livestore/utils'
-import { Option, type Schema, SchemaAST, type Types } from '@livestore/utils/effect'
+import { Option, Schema, SchemaAST, type Types } from '@livestore/utils/effect'
 
 import { getColumnDefForSchema, schemaFieldsToColumns } from './column-def.ts'
 import { SqliteDsl } from './db-schema/mod.ts'
@@ -221,7 +221,7 @@ export function table<
     ) as SqliteDsl.Columns
     additionalIndexes = []
   } else if ('schema' in args) {
-    const result = schemaFieldsToColumns(SchemaAST.getPropertySignatures(args.schema.ast))
+    const result = schemaFieldsToColumns(Schema.getResolvedPropertySignatures(args.schema))
     columns = result.columns
 
     // We'll set tableName first, then use it for index names
@@ -381,12 +381,13 @@ export declare namespace SchemaToColumns {
   export type ColumnDefForType<TEncoded, TType> = SqliteDsl.ColumnDefinition<TEncoded, TType>
 
   // Create columns type from schema Type and Encoded
-  export type FromTypes<TType, TEncoded> = TType extends Record<string, any>
-    ? TEncoded extends Record<string, any>
-      ? {
-          [K in keyof TType & keyof TEncoded]: ColumnDefForType<TEncoded[K], TType[K]>
-        }
-      : SqliteDsl.Columns
+  export type FromTypes<TType, TEncoded> = TEncoded extends Record<string, any>
+    ? {
+        [K in keyof TEncoded]-?: ColumnDefForType<
+          TEncoded[K],
+          TType extends Record<string, any> ? (K extends keyof TType ? TType[K] : TEncoded[K]) : TEncoded[K]
+        >
+      }
     : SqliteDsl.Columns
 }
 

package/src/sync/ClientSessionSyncProcessor.ts

@@ -94,7 +94,7 @@ export const makeClientSessionSyncProcessor = ({
     }),
   }
 
-  /** Only used for debugging / observability, it's not relied upon for correctness of the sync processor. */
+  /** Only used for debugging / observability / testing, it's not relied upon for correctness of the sync processor. */
   const syncStateUpdateQueue = Queue.unbounded<SyncState.SyncState>().pipe(Effect.runSync)
   const isClientEvent = (eventEncoded: LiveStoreEvent.EncodedWithMeta) =>
     getEventDef(schema, eventEncoded.name).eventDef.options.clientOnly
@@ -240,7 +240,6 @@ export const makeClientSessionSyncProcessor = ({
           }
 
           syncStateRef.current = mergeResult.newSyncState
-          yield* syncStateUpdateQueue.offer(mergeResult.newSyncState)
 
           if (mergeResult._tag === 'rebase') {
             span.addEvent('merge:pull:rebase', {
@@ -298,7 +297,11 @@ export const makeClientSessionSyncProcessor = ({
             debugInfo.advanceCount++
           }
 
-          if (mergeResult.newEvents.length === 0) return
+          if (mergeResult.newEvents.length === 0) {
+            // If there are no new events, we need to update the sync state as well
+            yield* syncStateUpdateQueue.offer(mergeResult.newSyncState)
+            return
+          }
 
           const writeTables = new Set<string>()
           for (const event of mergeResult.newEvents) {
@@ -321,6 +324,9 @@ export const makeClientSessionSyncProcessor = ({
           }
 
           refreshTables(writeTables)
+
+          // We're only triggering the sync state update after all events have been materialized
+          yield* syncStateUpdateQueue.offer(mergeResult.newSyncState)
         }).pipe(
           Effect.tapCauseLogPretty,
           Effect.catchAllCause((cause) => clientSession.shutdown(Exit.failCause(cause))),

package/src/sync/mock-sync-backend.ts

@@ -1,7 +1,8 @@
 import type { Schema, Scope } from '@livestore/utils/effect'
 import { Effect, Mailbox, Option, Queue, Stream, SubscriptionRef } from '@livestore/utils/effect'
-import type { UnexpectedError } from '../errors.ts'
+import { UnexpectedError } from '../errors.ts'
 import { EventSequenceNumber, type LiveStoreEvent } from '../schema/mod.ts'
+import { InvalidPushError } from './errors.ts'
 import * as SyncBackend from './sync-backend.ts'
 import { validatePushPayload } from './validate-push-payload.ts'
 
@@ -11,41 +12,118 @@ export interface MockSyncBackend {
   disconnect: Effect.Effect<void>
   makeSyncBackend: Effect.Effect<SyncBackend.SyncBackend, UnexpectedError, Scope.Scope>
   advance: (...batch: LiveStoreEvent.AnyEncodedGlobal[]) => Effect.Effect<void>
+  /** Fail the next N push calls with an InvalidPushError (or custom error) */
+  failNextPushes: (
+    count: number,
+    error?: (batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => Effect.Effect<never, InvalidPushError>,
+  ) => Effect.Effect<void>
 }
 
-export const makeMockSyncBackend: Effect.Effect<MockSyncBackend, UnexpectedError, Scope.Scope> = Effect.gen(
-  function* () {
+export interface MockSyncBackendOptions {
+  /** Chunk size for non-live pulls; defaults to 100 */
+  nonLiveChunkSize?: number
+  /** Initial connected state; defaults to false */
+  startConnected?: boolean
+  // TODO add a "flaky" mode to simulate transient network / server failures for pull/push
+}
+
+export const makeMockSyncBackend = (
+  options?: MockSyncBackendOptions,
+): Effect.Effect<MockSyncBackend, UnexpectedError, Scope.Scope> =>
+  Effect.gen(function* () {
     const syncEventSequenceNumberRef = { current: EventSequenceNumber.ROOT.global }
     const syncPullQueue = yield* Queue.unbounded<LiveStoreEvent.AnyEncodedGlobal>()
     const pushedEventsQueue = yield* Mailbox.make<LiveStoreEvent.AnyEncodedGlobal>()
-    const syncIsConnectedRef = yield* SubscriptionRef.make(true)
+    const syncIsConnectedRef = yield* SubscriptionRef.make(options?.startConnected ?? false)
+    const allEventsRef: { current: LiveStoreEvent.AnyEncodedGlobal[] } = { current: [] }
 
     const span = yield* Effect.currentSpan.pipe(Effect.orDie)
 
     const semaphore = yield* Effect.makeSemaphore(1)
 
+    // TODO improve the API and implementation of simulating errors
+    const failCounterRef = yield* SubscriptionRef.make(0)
+    const failEffectRef = yield* SubscriptionRef.make<
+      ((batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => Effect.Effect<never, InvalidPushError>) | undefined
+    >(undefined)
+
     const makeSyncBackend = Effect.gen(function* () {
+      const nonLiveChunkSize = Math.max(1, options?.nonLiveChunkSize ?? 100)
+
+      // TODO consider making offline state actively error pull/push.
+      // Currently, offline only reflects in `isConnected`, while operations still succeed,
+      // mirroring how some real providers behave during transient disconnects.
       return SyncBackend.of<Schema.JsonValue>({
         isConnected: syncIsConnectedRef,
-        connect: Effect.void,
+        connect: SubscriptionRef.set(syncIsConnectedRef, true),
         ping: Effect.void,
-        pull: () =>
-          Stream.fromQueue(syncPullQueue).pipe(
-            Stream.chunks,
-            Stream.map((chunk) => ({
-              batch: [...chunk].map((eventEncoded) => ({ eventEncoded, metadata: Option.none() })),
-              pageInfo: SyncBackend.pageInfoNoMore,
-            })),
-            Stream.withSpan('MockSyncBackend:pull', { parent: span }),
-          ),
+        pull: (cursor, options) =>
+          (options?.live
+            ? Stream.concat(
+                Stream.make(SyncBackend.pullResItemEmpty()),
+                Stream.fromQueue(syncPullQueue).pipe(
+                  Stream.chunks,
+                  Stream.map((chunk) => ({
+                    batch: [...chunk].map((eventEncoded) => ({ eventEncoded, metadata: Option.none() })),
+                    pageInfo: SyncBackend.pageInfoNoMore,
+                  })),
+                ),
+              )
+            : Stream.fromEffect(
+                Effect.sync(() => {
+                  const lastSeen = cursor.pipe(
+                    Option.match({
+                      onNone: () => EventSequenceNumber.ROOT.global,
+                      onSome: (_) => _.eventSequenceNumber,
+                    }),
+                  )
+                  // All events with seqNum greater than lastSeen
+                  const slice = allEventsRef.current.filter((e) => e.seqNum > lastSeen)
+                  // Split into configured chunk size
+                  const chunks: { events: LiveStoreEvent.AnyEncodedGlobal[]; remaining: number }[] = []
+                  for (let i = 0; i < slice.length; i += nonLiveChunkSize) {
+                    const end = Math.min(i + nonLiveChunkSize, slice.length)
+                    const remaining = Math.max(slice.length - end, 0)
+                    chunks.push({ events: slice.slice(i, end), remaining })
+                  }
+                  if (chunks.length === 0) {
+                    chunks.push({ events: [], remaining: 0 })
+                  }
+                  return chunks
+                }),
+              ).pipe(
+                Stream.flatMap((chunks) =>
+                  Stream.fromIterable(chunks).pipe(
+                    Stream.map(({ events, remaining }) => ({
+                      batch: events.map((eventEncoded) => ({ eventEncoded, metadata: Option.none() })),
+                      pageInfo: remaining > 0 ? SyncBackend.pageInfoMoreKnown(remaining) : SyncBackend.pageInfoNoMore,
+                    })),
+                  ),
+                ),
+              )
+          ).pipe(Stream.withSpan('MockSyncBackend:pull', { parent: span })),
         push: (batch) =>
           Effect.gen(function* () {
             yield* validatePushPayload(batch, syncEventSequenceNumberRef.current)
 
+            const remaining = yield* SubscriptionRef.get(failCounterRef)
+            if (remaining > 0) {
+              const maybeFail = yield* SubscriptionRef.get(failEffectRef)
+              // decrement counter first
+              yield* SubscriptionRef.set(failCounterRef, remaining - 1)
+              if (maybeFail) {
+                return yield* maybeFail(batch)
+              }
+              return yield* new InvalidPushError({
+                cause: new UnexpectedError({ cause: new Error('MockSyncBackend: simulated push failure') }),
+              })
+            }
+
             yield* Effect.sleep(10).pipe(Effect.withSpan('MockSyncBackend:push:sleep')) // Simulate network latency
 
             yield* pushedEventsQueue.offerAll(batch)
             yield* syncPullQueue.offerAll(batch)
+            allEventsRef.current = allEventsRef.current.concat(batch)
 
             syncEventSequenceNumberRef.current = batch.at(-1)!.seqNum
           }).pipe(
@@ -71,6 +149,7 @@ export const makeMockSyncBackend: Effect.Effect<MockSyncBackend, UnexpectedError
     const advance = (...batch: LiveStoreEvent.AnyEncodedGlobal[]) =>
       Effect.gen(function* () {
         syncEventSequenceNumberRef.current = batch.at(-1)!.seqNum
+        allEventsRef.current = allEventsRef.current.concat(batch)
         yield* syncPullQueue.offerAll(batch)
       }).pipe(
         Effect.withSpan('MockSyncBackend:advance', {
@@ -83,6 +162,15 @@ export const makeMockSyncBackend: Effect.Effect<MockSyncBackend, UnexpectedError
     const connect = SubscriptionRef.set(syncIsConnectedRef, true)
     const disconnect = SubscriptionRef.set(syncIsConnectedRef, false)
 
+    const failNextPushes = (
+      count: number,
+      error?: (batch: ReadonlyArray<LiveStoreEvent.AnyEncodedGlobal>) => Effect.Effect<never, InvalidPushError>,
+    ) =>
+      Effect.gen(function* () {
+        yield* SubscriptionRef.set(failCounterRef, count)
+        yield* SubscriptionRef.set(failEffectRef, error)
+      })
+
     return {
       syncEventSequenceNumberRef,
       syncPullQueue,
@@ -91,6 +179,6 @@ export const makeMockSyncBackend: Effect.Effect<MockSyncBackend, UnexpectedError
       disconnect,
       makeSyncBackend,
       advance,
+      failNextPushes,
     }
-  },
-).pipe(Effect.withSpanScoped('MockSyncBackend'))
+  }).pipe(Effect.withSpanScoped('MockSyncBackend'))

package/src/version.ts

@@ -2,7 +2,7 @@
 // import packageJson from '../package.json' with { type: 'json' }
 // export const liveStoreVersion = packageJson.version
 
-export const liveStoreVersion = '0.4.0-dev.6' as const
+export const liveStoreVersion = '0.4.0-dev.8' as const
 
 /**
  * This version number is incremented whenever the internal storage format changes in a breaking way.

package/dist/schema-management/migrations.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=migrations.test.d.ts.map

package/dist/schema-management/migrations.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"migrations.test.d.ts","sourceRoot":"","sources":["../../src/schema-management/migrations.test.ts"],"names":[],"mappings":""}

package/dist/schema-management/migrations.test.js

@@ -1,52 +0,0 @@
-import { Option, Schema } from '@livestore/utils/effect';
-import { describe, expect, it } from 'vitest';
-import { makeColumnSpec } from './migrations.js';
-const createColumn = (name, type, options = {}) => ({
-    _tag: 'column',
-    name,
-    type: { _tag: type },
-    nullable: options.nullable ?? true,
-    primaryKey: options.primaryKey ?? false,
-    default: Option.none(),
-    schema: type === 'text' ? Schema.String : Schema.Number,
-});
-describe('makeColumnSpec', () => {
-    it('should quote column names properly for reserved keywords', () => {
-        const table = {
-            _tag: 'table',
-            name: 'blocks',
-            columns: [createColumn('order', 'integer', { nullable: false }), createColumn('group', 'text')],
-            indexes: [],
-        };
-        const result = makeColumnSpec(table);
-        expect(result).toMatchInlineSnapshot(`"'order' integer not null , 'group' text  "`);
-        expect(result).toContain("'order'");
-        expect(result).toContain("'group'");
-    });
-    it('should handle basic columns with primary keys', () => {
-        const table = {
-            _tag: 'table',
-            name: 'users',
-            columns: [createColumn('id', 'text', { nullable: false, primaryKey: true }), createColumn('name', 'text')],
-            indexes: [],
-        };
-        const result = makeColumnSpec(table);
-        expect(result).toMatchInlineSnapshot(`"'id' text not null , 'name' text  , PRIMARY KEY ('id')"`);
-        expect(result).toContain("PRIMARY KEY ('id')");
-    });
-    it('should handle multi-column primary keys', () => {
-        const table = {
-            _tag: 'table',
-            name: 'composite',
-            columns: [
-                createColumn('tenant_id', 'text', { nullable: false, primaryKey: true }),
-                createColumn('user_id', 'text', { nullable: false, primaryKey: true }),
-            ],
-            indexes: [],
-        };
-        const result = makeColumnSpec(table);
-        expect(result).toMatchInlineSnapshot(`"'tenant_id' text not null , 'user_id' text not null , PRIMARY KEY ('tenant_id', 'user_id')"`);
-        expect(result).toContain("PRIMARY KEY ('tenant_id', 'user_id')");
-    });
-});
-//# sourceMappingURL=migrations.test.js.map

package/dist/schema-management/migrations.test.js.map

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