@delma/fylo 2.1.0 → 2.1.1

package/tests/collection/truncate.test.js

@@ -1,36 +0,0 @@
-import { test, expect, describe, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import { postsURL, albumURL } from '../data'
-import { createTestRoot } from '../helpers/root'
-const POSTS = `post`
-const ALBUMS = `album`
-const root = await createTestRoot('fylo-truncate-')
-afterAll(async () => {
-    const fylo = new Fylo({ root })
-    await Promise.all([fylo.dropCollection(ALBUMS), fylo.dropCollection(POSTS)])
-    await rm(root, { recursive: true, force: true })
-})
-describe('NO-SQL', () => {
-    test('TRUNCATE', async () => {
-        const fylo = new Fylo({ root })
-        await fylo.createCollection(POSTS)
-        await fylo.importBulkData(POSTS, new URL(postsURL))
-        await fylo.delDocs(POSTS)
-        const ids = []
-        for await (const data of fylo.findDocs(POSTS, { $limit: 1, $onlyIds: true }).collect()) {
-            ids.push(data)
-        }
-        expect(ids.length).toBe(0)
-    })
-})
-describe('SQL', () => {
-    test('TRUNCATE', async () => {
-        const fylo = new Fylo({ root })
-        await fylo.executeSQL(`CREATE TABLE ${ALBUMS}`)
-        await fylo.importBulkData(ALBUMS, new URL(albumURL))
-        await fylo.executeSQL(`DELETE FROM ${ALBUMS}`)
-        const ids = await fylo.executeSQL(`SELECT _id FROM ${ALBUMS} LIMIT 1`)
-        expect(ids.length).toBe(0)
-    })
-})

package/tests/data.js

@@ -1,97 +0,0 @@
-function makeDataUrl(data) {
-    return `data:application/json,${encodeURIComponent(JSON.stringify(data))}`
-}
-function generateAlbums() {
-    return Array.from({ length: 100 }, (_, index) => {
-        const id = index + 1
-        const userId = Math.ceil(id / 10)
-        const prefix = id <= 15 ? 'omnis' : id % 4 === 0 ? 'quidem' : 'album'
-        return {
-            id,
-            userId,
-            title: `${prefix} album ${id}`
-        }
-    })
-}
-function generatePosts() {
-    return Array.from({ length: 100 }, (_, index) => {
-        const id = index + 1
-        const userId = Math.ceil(id / 10)
-        return {
-            id,
-            userId,
-            title: `post title ${id}`,
-            body: `post body ${id} for user ${userId}`
-        }
-    })
-}
-function generateComments() {
-    return Array.from({ length: 100 }, (_, index) => {
-        const id = index + 1
-        return {
-            id,
-            postId: id,
-            name: `comment ${id}`,
-            email: `comment${id}@example.com`,
-            body: `comment body ${id}`
-        }
-    })
-}
-function generatePhotos() {
-    return Array.from({ length: 100 }, (_, index) => {
-        const id = index + 1
-        const title = id % 3 === 0 ? `test photo ${id}` : `photo ${id}`
-        return {
-            id,
-            albumId: Math.ceil(id / 10),
-            title,
-            url: `https://example.com/photos/${id}.jpg`,
-            thumbnailUrl: `https://example.com/photos/${id}-thumb.jpg`
-        }
-    })
-}
-function generateTodos() {
-    return Array.from({ length: 100 }, (_, index) => {
-        const id = index + 1
-        return {
-            id,
-            userId: Math.ceil(id / 10),
-            title: id % 4 === 0 ? `test todo ${id}` : `todo ${id}`,
-            completed: id % 2 === 0
-        }
-    })
-}
-function generateUsers() {
-    return Array.from({ length: 10 }, (_, index) => {
-        const id = index + 1
-        return {
-            id,
-            name: `User ${id}`,
-            username: `user${id}`,
-            email: `user${id}@example.com`,
-            address: {
-                street: `Main Street ${id}`,
-                suite: `Suite ${id}`,
-                city: id <= 5 ? 'South Christy' : 'North Christy',
-                zipcode: `0000${id}`,
-                geo: {
-                    lat: 10 + id,
-                    lng: -20 - id
-                }
-            },
-            phone: `555-000-${String(id).padStart(4, '0')}`,
-            website: `user${id}.example.com`,
-            company: {
-                name: id <= 5 ? 'Acme Labs' : 'Northwind Labs',
-                catchPhrase: `Catch phrase ${id}`,
-                bs: `business ${id}`
-            }
-        }
-    })
-}
-export const albumURL = makeDataUrl(generateAlbums())
-export const postsURL = makeDataUrl(generatePosts())
-export const commentsURL = makeDataUrl(generateComments())
-export const photosURL = makeDataUrl(generatePhotos())
-export const todosURL = makeDataUrl(generateTodos())
-export const usersURL = makeDataUrl(generateUsers())

package/tests/helpers/root.js

@@ -1,7 +0,0 @@
-import { mkdtemp } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-
-export async function createTestRoot(prefix = 'fylo-test-') {
-    return await mkdtemp(path.join(os.tmpdir(), prefix))
-}

package/tests/integration/aws-s3-files.canary.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import Fylo from '../../src'
-const runCanary = process.env.FYLO_RUN_S3FILES_CANARY === 'true'
-const canaryTest = runCanary ? test : test.skip
-describe('aws s3-files canary', () => {
-    canaryTest('mounted S3 Files root handles a real CRUD cycle', async () => {
-        const collection = `canary_${Date.now()}`
-        const fylo = new Fylo({
-            engine: 's3-files',
-            s3FilesRoot: process.env.FYLO_S3FILES_ROOT
-        })
-        await fylo.createCollection(collection)
-        const id = await fylo.putData(collection, {
-            title: 'canary',
-            tags: ['aws', 's3-files']
-        })
-        const doc = await fylo.getDoc(collection, id).once()
-        expect(doc[id].title).toBe('canary')
-        await fylo.delDoc(collection, id)
-        await fylo.dropCollection(collection)
-    })
-})

package/tests/integration/create.test.js

@@ -1,39 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import { albumURL, postsURL } from '../data'
-import { createTestRoot } from '../helpers/root'
-const POSTS = `post`
-const ALBUMS = `album`
-let postsCount = 0
-let albumsCount = 0
-const root = await createTestRoot('fylo-create-')
-const fylo = new Fylo({ root })
-beforeAll(async () => {
-    await Promise.all([fylo.createCollection(POSTS), fylo.executeSQL(`CREATE TABLE ${ALBUMS}`)])
-    try {
-        albumsCount = await fylo.importBulkData(ALBUMS, new URL(albumURL), 100)
-        postsCount = await fylo.importBulkData(POSTS, new URL(postsURL), 100)
-    } catch {
-        await fylo.rollback()
-    }
-})
-afterAll(async () => {
-    await Promise.all([fylo.dropCollection(POSTS), fylo.executeSQL(`DROP TABLE ${ALBUMS}`)])
-    await rm(root, { recursive: true, force: true })
-})
-describe('NO-SQL', async () => {
-    test('PUT', async () => {
-        let results = {}
-        for await (const data of fylo.findDocs(POSTS).collect()) {
-            results = { ...results, ...data }
-        }
-        expect(Object.keys(results).length).toEqual(postsCount)
-    })
-})
-describe('SQL', () => {
-    test('INSERT', async () => {
-        const results = await fylo.executeSQL(`SELECT * FROM ${ALBUMS}`)
-        expect(Object.keys(results).length).toEqual(albumsCount)
-    })
-})

package/tests/integration/delete.test.js

@@ -1,97 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import { commentsURL, usersURL } from '../data'
-import { createTestRoot } from '../helpers/root'
-const COMMENTS = `comment`
-const USERS = `user`
-let commentsResults = {}
-let usersResults = {}
-const root = await createTestRoot('fylo-delete-')
-const fylo = new Fylo({ root })
-beforeAll(async () => {
-    await Promise.all([fylo.createCollection(COMMENTS), fylo.executeSQL(`CREATE TABLE ${USERS}`)])
-    try {
-        await Promise.all([
-            fylo.importBulkData(COMMENTS, new URL(commentsURL), 100),
-            fylo.importBulkData(USERS, new URL(usersURL), 100)
-        ])
-    } catch {
-        await fylo.rollback()
-    }
-    for await (const data of fylo.findDocs(COMMENTS, { $limit: 1 }).collect()) {
-        commentsResults = { ...commentsResults, ...data }
-    }
-    usersResults = await fylo.executeSQL(`SELECT * FROM ${USERS} LIMIT 1`)
-})
-afterAll(async () => {
-    await Promise.all([fylo.dropCollection(COMMENTS), fylo.executeSQL(`DROP TABLE ${USERS}`)])
-    await rm(root, { recursive: true, force: true })
-})
-describe('NO-SQL', async () => {
-    test('DELETE ONE', async () => {
-        const id = Object.keys(commentsResults).shift()
-        try {
-            await fylo.delDoc(COMMENTS, id)
-        } catch {
-            await fylo.rollback()
-        }
-        commentsResults = {}
-        for await (const data of fylo.findDocs(COMMENTS).collect()) {
-            commentsResults = { ...commentsResults, ...data }
-        }
-        const idx = Object.keys(commentsResults).findIndex((_id) => _id === id)
-        expect(idx).toEqual(-1)
-    })
-    test('DELETE CLAUSE', async () => {
-        try {
-            await fylo.delDocs(COMMENTS, { $ops: [{ name: { $like: '%et%' } }] })
-        } catch (e) {
-            console.error(e)
-            await fylo.rollback()
-        }
-        commentsResults = {}
-        for await (const data of fylo
-            .findDocs(COMMENTS, {
-                $ops: [{ name: { $like: '%et%' } }]
-            })
-            .collect()) {
-            commentsResults = { ...commentsResults, ...data }
-        }
-        expect(Object.keys(commentsResults).length).toEqual(0)
-    })
-    test('DELETE ALL', async () => {
-        try {
-            await fylo.delDocs(COMMENTS)
-        } catch {
-            await fylo.rollback()
-        }
-        commentsResults = {}
-        for await (const data of fylo.findDocs(COMMENTS).collect()) {
-            commentsResults = { ...commentsResults, ...data }
-        }
-        expect(Object.keys(commentsResults).length).toEqual(0)
-    })
-})
-describe('SQL', async () => {
-    test('DELETE CLAUSE', async () => {
-        const name = Object.values(usersResults).shift().name
-        try {
-            await fylo.executeSQL(`DELETE FROM ${USERS} WHERE name = '${name}'`)
-        } catch {
-            await fylo.rollback()
-        }
-        usersResults = await fylo.executeSQL(`SELECT * FROM ${USERS} WHERE name = '${name}'`)
-        const idx = Object.values(usersResults).findIndex((com) => com.name === name)
-        expect(idx).toBe(-1)
-    })
-    test('DELETE ALL', async () => {
-        try {
-            await fylo.executeSQL(`DELETE FROM ${USERS}`)
-        } catch {
-            await fylo.rollback()
-        }
-        usersResults = await fylo.executeSQL(`SELECT * FROM ${USERS}`)
-        expect(Object.keys(usersResults).length).toBe(0)
-    })
-})

package/tests/integration/edge-cases.test.js

@@ -1,162 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import TTID from '@delma/ttid'
-import { createTestRoot } from '../helpers/root'
-const COLLECTION = 'ec-test'
-const root = await createTestRoot('fylo-edge-')
-const fylo = new Fylo({ root })
-beforeAll(async () => {
-    await fylo.createCollection(COLLECTION)
-})
-afterAll(async () => {
-    await fylo.dropCollection(COLLECTION)
-    await rm(root, { recursive: true, force: true })
-})
-describe('NO-SQL', () => {
-    test('GET ONE — non-existent ID returns empty object', async () => {
-        const fakeId = TTID.generate()
-        const result = await fylo.getDoc(COLLECTION, fakeId).once()
-        expect(Object.keys(result).length).toBe(0)
-    })
-    test('PUT / GET — forward slashes in values round-trip correctly', async () => {
-        const original = {
-            userId: 1,
-            id: 1,
-            title: 'Slash Test',
-            body: 'https://example.com/api/v1/resource'
-        }
-        const _id = await fylo.putData(COLLECTION, original)
-        const result = await fylo.getDoc(COLLECTION, _id).once()
-        const doc = result[_id]
-        expect(doc.body).toBe(original.body)
-        await fylo.delDoc(COLLECTION, _id)
-    })
-    test('PUT / GET — values with multiple consecutive slashes round-trip correctly', async () => {
-        const original = {
-            userId: 1,
-            id: 2,
-            title: 'Double Slash',
-            body: 'https://cdn.example.com//assets//image.png'
-        }
-        const _id = await fylo.putData(COLLECTION, original)
-        const result = await fylo.getDoc(COLLECTION, _id).once()
-        expect(result[_id].body).toBe(original.body)
-        await fylo.delDoc(COLLECTION, _id)
-    })
-    test('$ops — multiple conditions act as OR union', async () => {
-        const cleanFylo = new Fylo({ root })
-        const id1 = await cleanFylo.putData(COLLECTION, {
-            userId: 10,
-            id: 100,
-            title: 'Alpha',
-            body: 'first'
-        })
-        const id2 = await cleanFylo.putData(COLLECTION, {
-            userId: 20,
-            id: 200,
-            title: 'Beta',
-            body: 'second'
-        })
-        const results = {}
-        for await (const data of fylo
-            .findDocs(COLLECTION, {
-                $ops: [{ userId: { $eq: 10 } }, { userId: { $eq: 20 } }]
-            })
-            .collect()) {
-            Object.assign(results, data)
-        }
-        expect(results[id1]).toBeDefined()
-        expect(results[id2]).toBeDefined()
-        await cleanFylo.delDoc(COLLECTION, id1)
-        await cleanFylo.delDoc(COLLECTION, id2)
-    })
-    test('$rename — renames fields in query output', async () => {
-        const cleanFylo = new Fylo({ root })
-        const _id = await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 300,
-            title: 'Rename Me',
-            body: 'some body'
-        })
-        let renamed = {}
-        for await (const data of fylo
-            .findDocs(COLLECTION, {
-                $ops: [{ id: { $eq: 300 } }],
-                $rename: { title: 'name' }
-            })
-            .collect()) {
-            renamed = Object.values(data)[0]
-        }
-        expect(renamed.name).toBe('Rename Me')
-        expect(renamed.title).toBeUndefined()
-        await cleanFylo.delDoc(COLLECTION, _id)
-    })
-    test('versioned putData — preserves creation-time prefix in TTID', async () => {
-        const cleanFylo = new Fylo({ root })
-        const _id1 = await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 400,
-            title: 'Original',
-            body: 'v1'
-        })
-        const _id2 = await cleanFylo.putData(COLLECTION, {
-            [_id1]: { userId: 1, id: 400, title: 'Updated', body: 'v2' }
-        })
-        expect(_id2.split('-')[0]).toBe(_id1.split('-')[0])
-        const result = await fylo.getDoc(COLLECTION, _id2).once()
-        const doc = result[_id2]
-        expect(doc).toBeDefined()
-        expect(doc.title).toBe('Updated')
-        await cleanFylo.delDoc(COLLECTION, _id1)
-        await cleanFylo.delDoc(COLLECTION, _id2)
-    })
-    test('versioned putData — original version is no longer retrievable by old full TTID', async () => {
-        const cleanFylo = new Fylo({ root })
-        const _id1 = await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 500,
-            title: 'Old Version',
-            body: 'original'
-        })
-        const _id2 = await cleanFylo.putData(COLLECTION, {
-            [_id1]: { userId: 1, id: 500, title: 'New Version', body: 'updated' }
-        })
-        expect(_id1).not.toBe(_id2)
-        await cleanFylo.delDoc(COLLECTION, _id2)
-    })
-})
-describe('SQL', () => {
-    test('UPDATE ONE — update a single document by querying its unique field', async () => {
-        const cleanFylo = new Fylo({ root })
-        await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 600,
-            title: 'Before SQL Update',
-            body: 'original'
-        })
-        const updated = await cleanFylo.executeSQL(
-            `UPDATE ${COLLECTION} SET title = 'After SQL Update' WHERE id = 600`
-        )
-        expect(updated).toBe(1)
-        const results = await cleanFylo.executeSQL(
-            `SELECT * FROM ${COLLECTION} WHERE title = 'After SQL Update'`
-        )
-        expect(Object.keys(results).length).toBe(1)
-        expect(Object.values(results)[0].title).toBe('After SQL Update')
-    })
-    test('DELETE ONE — delete a single document by querying its unique field', async () => {
-        const cleanFylo = new Fylo({ root })
-        await cleanFylo.putData(COLLECTION, {
-            userId: 1,
-            id: 700,
-            title: 'Delete Via SQL',
-            body: 'should be removed'
-        })
-        await cleanFylo.executeSQL(`DELETE FROM ${COLLECTION} WHERE title = 'Delete Via SQL'`)
-        const results = await cleanFylo.executeSQL(
-            `SELECT * FROM ${COLLECTION} WHERE title = 'Delete Via SQL'`
-        )
-        expect(Object.keys(results).length).toBe(0)
-    })
-})

package/tests/integration/encryption.test.js

@@ -1,148 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
-import { readFile, rm } from 'node:fs/promises'
-import path from 'node:path'
-import Fylo from '../../src'
-import { createTestRoot } from '../helpers/root'
-import { CipherMock } from '../mocks/cipher'
-const COLLECTION = 'encrypted-test'
-const root = await createTestRoot('fylo-encryption-')
-const fylo = new Fylo({ root })
-mock.module('../../src/adapters/cipher', () => ({ Cipher: CipherMock }))
-beforeAll(async () => {
-    await fylo.createCollection(COLLECTION)
-    await CipherMock.configure('test-secret-key')
-    CipherMock.registerFields(COLLECTION, ['email', 'ssn', 'address'])
-})
-afterAll(async () => {
-    CipherMock.reset()
-    await fylo.dropCollection(COLLECTION)
-    await rm(root, { recursive: true, force: true })
-})
-describe('Encryption', () => {
-    let docId
-    test('PUT encrypted document', async () => {
-        docId = await fylo.putData(COLLECTION, {
-            name: 'Alice',
-            email: 'alice@example.com',
-            ssn: '123-45-6789',
-            age: 30
-        })
-        expect(docId).toBeDefined()
-    })
-    test('GET decrypts fields transparently', async () => {
-        const result = await fylo.getDoc(COLLECTION, docId).once()
-        const doc = Object.values(result)[0]
-        expect(doc.name).toBe('Alice')
-        expect(doc.email).toBe('alice@example.com')
-        expect(doc.ssn).toBe('123-45-6789')
-        expect(doc.age).toBe(30)
-    })
-    test('encrypted values stored in the doc file are not plaintext', async () => {
-        const raw = await readFile(
-            path.join(root, COLLECTION, '.fylo', 'docs', docId.slice(0, 2), `${docId}.json`),
-            'utf8'
-        )
-        expect(raw).not.toContain('alice@example.com')
-        expect(raw).not.toContain('123-45-6789')
-    })
-    test('$eq query works on encrypted field', async () => {
-        let found = false
-        for await (const data of fylo
-            .findDocs(COLLECTION, {
-                $ops: [{ email: { $eq: 'alice@example.com' } }]
-            })
-            .collect()) {
-            if (typeof data === 'object') {
-                const doc = Object.values(data)[0]
-                expect(doc.email).toBe('alice@example.com')
-                found = true
-            }
-        }
-        expect(found).toBe(true)
-    })
-    test('$ne throws on encrypted field', async () => {
-        try {
-            const iter = fylo
-                .findDocs(COLLECTION, {
-                    $ops: [{ email: { $ne: 'bob@example.com' } }]
-                })
-                .collect()
-            await iter.next()
-            expect(true).toBe(false)
-        } catch (e) {
-            expect(e.message).toContain('not supported on encrypted field')
-        }
-    })
-    test('$gt throws on encrypted field', async () => {
-        try {
-            const iter = fylo
-                .findDocs(COLLECTION, {
-                    $ops: [{ ssn: { $gt: 0 } }]
-                })
-                .collect()
-            await iter.next()
-            expect(true).toBe(false)
-        } catch (e) {
-            expect(e.message).toContain('not supported on encrypted field')
-        }
-    })
-    test('$like throws on encrypted field', async () => {
-        try {
-            const iter = fylo
-                .findDocs(COLLECTION, {
-                    $ops: [{ email: { $like: '%@example.com' } }]
-                })
-                .collect()
-            await iter.next()
-            expect(true).toBe(false)
-        } catch (e) {
-            expect(e.message).toContain('not supported on encrypted field')
-        }
-    })
-    test('non-encrypted fields remain queryable with all operators', async () => {
-        let found = false
-        for await (const data of fylo
-            .findDocs(COLLECTION, {
-                $ops: [{ name: { $eq: 'Alice' } }]
-            })
-            .collect()) {
-            if (typeof data === 'object') {
-                const doc = Object.values(data)[0]
-                expect(doc.name).toBe('Alice')
-                found = true
-            }
-        }
-        expect(found).toBe(true)
-    })
-    test('nested encrypted field (address.city)', async () => {
-        const id = await fylo.putData(COLLECTION, {
-            name: 'Bob',
-            email: 'bob@example.com',
-            ssn: '987-65-4321',
-            age: 25,
-            address: { city: 'Toronto', zip: 'M5V 2T6' }
-        })
-        const result = await fylo.getDoc(COLLECTION, id).once()
-        const doc = Object.values(result)[0]
-        expect(doc.address.city).toBe('Toronto')
-        expect(doc.address.zip).toBe('M5V 2T6')
-    })
-    test('UPDATE preserves encryption', async () => {
-        await fylo.patchDoc(COLLECTION, {
-            [docId]: { email: 'alice-new@example.com' }
-        })
-        let found = false
-        for await (const data of fylo
-            .findDocs(COLLECTION, {
-                $ops: [{ email: { $eq: 'alice-new@example.com' } }]
-            })
-            .collect()) {
-            if (typeof data === 'object') {
-                const doc = Object.values(data)[0]
-                expect(doc.email).toBe('alice-new@example.com')
-                found = true
-            }
-        }
-        expect(found).toBe(true)
-    })
-})

package/tests/integration/export.test.js

@@ -1,46 +0,0 @@
-import { test, expect, describe, beforeAll, afterAll } from 'bun:test'
-import { rm } from 'node:fs/promises'
-import Fylo from '../../src'
-import { postsURL } from '../data'
-import { createTestRoot } from '../helpers/root'
-const POSTS = 'exp-post'
-const IMPORT_LIMIT = 20
-let importedCount = 0
-const root = await createTestRoot('fylo-export-')
-const fylo = new Fylo({ root })
-beforeAll(async () => {
-    await fylo.createCollection(POSTS)
-    try {
-        importedCount = await fylo.importBulkData(POSTS, new URL(postsURL), IMPORT_LIMIT)
-    } catch {
-        await fylo.rollback()
-    }
-})
-afterAll(async () => {
-    await fylo.dropCollection(POSTS)
-    await rm(root, { recursive: true, force: true })
-})
-describe('NO-SQL', () => {
-    test('EXPORT count matches import', async () => {
-        let exported = 0
-        for await (const _doc of fylo.exportBulkData(POSTS)) {
-            exported++
-        }
-        expect(exported).toBe(importedCount)
-    })
-    test('EXPORT document shape', async () => {
-        for await (const doc of fylo.exportBulkData(POSTS)) {
-            expect(doc).toHaveProperty('title')
-            expect(doc).toHaveProperty('userId')
-            expect(doc).toHaveProperty('body')
-            break
-        }
-    })
-    test('EXPORT all documents are valid posts', async () => {
-        for await (const doc of fylo.exportBulkData(POSTS)) {
-            expect(typeof doc.title).toBe('string')
-            expect(typeof doc.userId).toBe('number')
-            expect(doc.userId).toBeGreaterThan(0)
-        }
-    })
-})