Add Prettier formatting and Gitea Actions CI (format, typecheck, test, build)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017Qxbkp4tA7G5SCWjzWuxmE

test/documents/event-sourced.test.ts

@@ -157,7 +157,7 @@ describe.each([
     it('evaluates comparison, logical and element operators', async () => {
       const { users } = await seed()
       // Unsorted results come in index or key order depending on the plan; compare as sets.
-    const q = async (f: Filter) => (await keysOf(users.find(f))).sort()
+      const q = async (f: Filter) => (await keysOf(users.find(f))).sort()
       expect(await q({})).toEqual(['a', 'b', 'c', 'd', 'e'])
       expect(await q({ age: 20 })).toEqual(['b', 'd'])
       expect(await q({ age: { $gte: 20, $lt: 40 } })).toEqual(['a', 'b', 'd'])
@@ -186,7 +186,9 @@ describe.each([
       expect(await keysOf(users.find({}, { sort: { name: -1 }, skip: 1, limit: 2 }))).toEqual(['d', 'c'])
       expect(await keysOf(users.find({ age: { $gte: 20 } }, { sort: { age: -1 }, limit: 2 }))).toEqual(['c', 'a'])
       expect(await keysOf(users.find({ 'address.city': 'London' }, { sort: { age: 1 } }))).toEqual(['e', 'a', 'c'])
-      expect(await collect(users.find({ age: 36 }, { projection: { name: 1, 'address.city': 1 } }))).toEqual([{ key: 'a', data: { name: 'Ada', address: { city: 'London' } } }])
+      expect(await collect(users.find({ age: 36 }, { projection: { name: 1, 'address.city': 1 } }))).toEqual([
+        { key: 'a', data: { name: 'Ada', address: { city: 'London' } } },
+      ])
       expect(await collect(users.find({ age: 36 }, { projection: { tags: 0, address: 0, email: 0 } }))).toEqual([{ key: 'a', data: { name: 'Ada', age: 36 } }])
       expect(await users.findOne({ email: 'bob@x' })).toEqual({ key: 'b', data: expect.objectContaining({ name: 'Bob' }) })
       expect(await users.findOne({ email: 'nobody' })).toBeUndefined()
@@ -278,7 +280,11 @@ describe.each([
 
     it('catchUp() repairs a subtree', async () => {
       const { users, docs, events } = await lagged()
-      await events.child('users').child('9').child('posts').append('p', [{ op: 'set', doc: { createdAt: 'x' } }])
+      await events
+        .child('users')
+        .child('9')
+        .child('posts')
+        .append('p', [{ op: 'set', doc: { createdAt: 'x' } }])
       expect(await docs.catchUp()).toBe(2)
       expect(await users.get('1')).toEqual({ n: 2, email: 'b@x' })
       expect(await users.child('9').child('posts').get('p')).toEqual({ createdAt: 'x' })
@@ -339,28 +345,34 @@ describe('property: indexed find equals unindexed find', () => {
 
   it('returns the same results in the same order', async () => {
     await fc.assert(
-      fc.asyncProperty(fc.array(fc.tuple(fc.constantFrom('1', '2', '3', '4', '5'), doc), { maxLength: 12 }), filter, sort, fc.option(fc.integer({ min: 1, max: 4 }), { nil: undefined }), async (writes, f, s, limit) => {
-        const plain = new EventSourcedDocumentStorage(new KVEventStorage(new KVStorage(new InMemoryKVDriver())), { warnOnFullScan: false }).child('users')
-        const indexed = new EventSourcedDocumentStorage(new KVEventStorage(new KVStorage(new InMemoryKVDriver())), {
-          warnOnFullScan: false,
-          indexes: { users: userIndexes.users!.map((i) => ({ ...i, unique: false })) },
-        }).child('users')
-        for (const [k, v] of writes) {
-          await plain.set(k, v)
-          await indexed.set(k, v)
-        }
-        const opts = { ...(s ? { sort: s } : {}), ...(limit ? { limit } : {}) }
-        const a = await collect(plain.find(f, opts))
-        const b = await collect(indexed.find(f, opts))
-        if (s) {
-          expect(b).toEqual(a)
-          return
-        }
-        // Unsorted order depends on the plan: compare as sets (a limited result is any subset of that size).
-        const all = new Set((await collect(plain.find(f))).map((r) => r.key))
-        expect(b).toHaveLength(a.length)
-        for (const r of b) expect(all.has(r.key)).toBe(true)
-      }),
+      fc.asyncProperty(
+        fc.array(fc.tuple(fc.constantFrom('1', '2', '3', '4', '5'), doc), { maxLength: 12 }),
+        filter,
+        sort,
+        fc.option(fc.integer({ min: 1, max: 4 }), { nil: undefined }),
+        async (writes, f, s, limit) => {
+          const plain = new EventSourcedDocumentStorage(new KVEventStorage(new KVStorage(new InMemoryKVDriver())), { warnOnFullScan: false }).child('users')
+          const indexed = new EventSourcedDocumentStorage(new KVEventStorage(new KVStorage(new InMemoryKVDriver())), {
+            warnOnFullScan: false,
+            indexes: { users: userIndexes.users!.map((i) => ({ ...i, unique: false })) },
+          }).child('users')
+          for (const [k, v] of writes) {
+            await plain.set(k, v)
+            await indexed.set(k, v)
+          }
+          const opts = { ...(s ? { sort: s } : {}), ...(limit ? { limit } : {}) }
+          const a = await collect(plain.find(f, opts))
+          const b = await collect(indexed.find(f, opts))
+          if (s) {
+            expect(b).toEqual(a)
+            return
+          }
+          // Unsorted order depends on the plan: compare as sets (a limited result is any subset of that size).
+          const all = new Set((await collect(plain.find(f))).map((r) => r.key))
+          expect(b).toHaveLength(a.length)
+          for (const r of b) expect(all.has(r.key)).toBe(true)
+        },
+      ),
       { numRuns: 300 },
     )
   })

test/documents/units.test.ts

@@ -45,7 +45,13 @@ describe('filter semantics', () => {
 
 describe('update resolution', () => {
   it('$pull by sub-document filter and by condition', () => {
-    const state = { items: [{ k: 1, v: 'a' }, { k: 2, v: 'b' }], n: [1, 5, 9] }
+    const state = {
+      items: [
+        { k: 1, v: 'a' },
+        { k: 2, v: 'b' },
+      ],
+      n: [1, 5, 9],
+    }
     const patch = resolveUpdate(state, { $pull: { items: { k: 2 }, n: { $gte: 5 } } })
     expect(applyPatch(state, patch)).toEqual({ items: [{ k: 1, v: 'a' }], n: [1] })
   })