@delma/fylo 1.0.0

package/src/types/fylo.d.ts

@@ -0,0 +1,139 @@
+interface _getDoc {
+    [Symbol.asyncIterator]<T>(): AsyncGenerator<_ttid | Record<_ttid, T>, void, unknown>;
+    once<T>(): Promise<Record<_ttid, T>>
+    onDelete(): AsyncGenerator<_ttid, void, unknown>
+}
+
+interface _findDocs {
+    [Symbol.asyncIterator]<T>(): AsyncGenerator<_ttid | Record<_ttid, T> | Record<string, _ttid[]> | Record<_ttid, Partial<T>> | undefined, void, unknown>
+    once<T>(): Promise<Record<_ttid, T>>
+    onDelete(): AsyncGenerator<_ttid, void, unknown>
+}
+
+interface ObjectConstructor {
+    appendGroup: (target: Record<string, any>, source: Record<string, any>) => Record<string, any>;
+}
+
+interface Console {
+    format: (docs: Record<string, any>) => void
+}
+
+type _joinDocs<T, U> = _ttid[] | Record<string, _ttid[]> | Record<string,  Record<_ttid, Partial<T | U>>> | Record<`${_ttid}, ${_ttid}`, T | U | (T & U) | (Partial<T> & Partial<U>)>
+
+declare module "@vyckr/fylo" {
+
+    export default class {
+
+        /**
+         * Rolls back all transcations in current instance
+         */
+        rollback(): Promise<void>
+
+        /**
+         * Executes a SQL query and returns the results.
+         * @param SQL The SQL query to execute.
+         * @returns The results of the query.
+         */
+        executeSQL<T extends Record<string, any>, U extends Record<string, any> = {}>(SQL: string): Promise<number | void | any[] | _ttid | Record<any, any>>
+        
+        /**
+         * Creates a new schema for a collection.
+         * @param collection The name of the collection.
+         */
+        static createCollection(collection: string): Promise<void>
+
+        /**
+         * Drops an existing schema for a collection.
+         * @param collection The name of the collection.
+         */
+        static dropCollection(collection: string): Promise<void>
+
+        /**
+         * Imports data from a URL into a collection.
+         * @param collection The name of the collection.
+         * @param url The URL of the data to import.
+         * @param limit The maximum number of documents to import.
+         */
+        importBulkData(collection: string, url: URL, limit?: number): Promise<number>
+
+        /**
+         * Exports data from a collection to a URL.
+         * @param collection The name of the collection.
+         * @returns The current data exported from the collection.
+         */
+        exportBulkData<T extends Record<string, any>>(collection: string): AsyncGenerator<T, void, unknown>
+
+        /**
+         * Gets a document from a collection.
+         * @param collection The name of the collection.
+         * @param _id The ID of the document.
+         * @param onlyId Whether to only return the ID of the document.
+         * @returns The document or the ID of the document.
+         */
+        static getDoc(collection: string, _id: _ttid, onlyId: boolean): _getDoc
+
+        /**
+         * Puts multiple documents into a collection.
+         * @param collection The name of the collection.
+         * @param batch The documents to put.
+         * @returns The IDs of the documents.
+         */
+        batchPutData<T extends Record<string, any>>(collection: string, batch: Array<T>): Promise<_ttid[]>
+
+        /**
+         * Puts a document into a collection.
+         * @param collection The name of the collection.
+         * @param data The document to put.
+         * @returns The ID of the document.
+         */
+        putData<T extends Record<string, any>>(collection: string, data: Record<_ttid, T> | T): Promise<_ttid>
+
+        /**
+         * Patches a document in a collection.
+         * @param collection The name of the collection.
+         * @param newDoc The new document data.
+         * @param oldDoc The old document data.
+         * @returns The number of documents patched.
+         */
+        patchDoc<T extends Record<string, any>>(collection: string, newDoc: Record<_ttid, Partial<T>>, oldDoc: Record<_ttid, T>): Promise<_ttid>
+
+        /**
+         * Patches documents in a collection.
+         * @param collection The name of the collection.
+         * @param updateSchema The update schema.
+         * @returns The number of documents patched.
+         */
+        patchDocs<T extends Record<string, any>>(collection: string, updateSchema: _storeUpdate<T>): Promise<number>
+
+        /**
+         * Deletes a document from a collection.
+         * @param collection The name of the collection.
+         * @param _id The ID of the document.
+         * @returns The number of documents deleted.
+         */
+        delDoc(collection: string, _id: _ttid): Promise<void>
+
+        /**
+         * Deletes documents from a collection.
+         * @param collection The name of the collection.
+         * @param deleteSchema The delete schema.
+         * @returns The number of documents deleted.
+         */
+        delDocs<T extends Record<string, any>>(collection: string, deleteSchema?: _storeDelete<T>): Promise<number>
+
+        /**
+         * Joins documents from two collections.
+         * @param join The join schema.
+         * @returns The joined documents.
+         */
+        static joinDocs<T extends Record<string, any>, U extends Record<string, any>>(join: _join<T, U>): Promise<_joinDocs<T, U>>
+        
+        /**
+         * Finds documents in a collection.
+         * @param collection The name of the collection.
+         * @param query The query schema.
+         * @returns The found documents.
+         */
+        static findDocs<T extends Record<string, any>>(collection: string, query?: _storeQuery<T>): _findDocs
+    }
+}

package/src/types/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference path="./query.d.ts" />
+/// <reference path="./fylo.d.ts" />
+/// <reference types="@vyckr/ttid" />

package/src/types/query.d.ts

@@ -0,0 +1,73 @@
+interface _joinOperand<U> {
+    $eq?: keyof U
+    $ne?: keyof U
+    $gt?: keyof U
+    $lt?: keyof U
+    $gte?: keyof U
+    $lte?: keyof U
+}
+
+interface _timestamp {
+    $gt?: number
+    $lt?: number
+    $gte?: number
+    $lte?: number
+}
+
+interface _operand {
+    $eq?: any
+    $ne?: any
+    $gt?: number
+    $lt?: number
+    $gte?: number
+    $lte?: number
+    $like?: string
+    $contains?: string | number | boolean
+}
+
+type _op<T> = Partial<Record<keyof T, _operand>>
+
+type _on<T, U> = Partial<Record<keyof T, _joinOperand<U>>>
+
+type _join<T, U> = {
+    $select?: Array<keyof T | keyof U>
+    $leftCollection: string
+    $rightCollection: string
+    $mode: "inner" | "left" | "right" | "outer"
+    $on: _on<T, U>
+    $limit?: number
+    $onlyIds?: boolean
+    $groupby?: keyof T | keyof U
+    $rename?: Record<keyof Partial<T> | keyof Partial<U>, string>
+}
+
+interface _storeQuery<T extends Record<string, any>> {
+    $select?: Array<keyof T>
+    $rename?: Record<keyof Partial<T>, string>
+    $collection?: string
+    $ops?: Array<_op<T>>
+    $limit?: number
+    $onlyIds?: boolean
+    $groupby?: keyof T
+    $updated?: _timestamp
+    $created?: _timestamp
+}
+
+interface _condition { column: string, operator: string, value: string | number| boolean | null }
+
+type _storeUpdate<T extends Record<string, any>> = {
+    $collection?: string
+    $where?: _storeQuery<T>
+    $set: {
+        [K in keyof Partial<T>]: T[K]
+    }
+}
+
+type _storeDelete<T extends Record<string, any>> = _storeQuery<T>
+
+type _storeInsert<T extends Record<string, any>> = {
+    $collection?: string
+    $values: {
+        [K in keyof T]: T[K]
+    }
+}

package/tests/collection/truncate.test.ts

@@ -0,0 +1,56 @@
+import { test, expect, describe, afterAll, mock } from 'bun:test'
+import Fylo from '../../src'
+import { postsURL, albumURL } from '../data'
+import S3Mock from '../mocks/s3'
+import RedisMock from '../mocks/redis'
+
+const POSTS = `post`
+const ALBUMS = `album`
+
+afterAll(async () => {
+    await Promise.all([Fylo.dropCollection(ALBUMS), Fylo.dropCollection(POSTS)])
+})
+
+mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
+mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
+
+describe("NO-SQL", () => {
+
+    test("TRUNCATE", async () => {
+
+        const fylo = new Fylo()
+
+        await Fylo.createCollection(POSTS)
+
+        await fylo.importBulkData<_post>(POSTS, new URL(postsURL))
+
+        await fylo.delDocs<_post>(POSTS)
+
+        const ids: _ttid[] = []
+
+        for await (const data of Fylo.findDocs<_post>(POSTS, { $limit: 1, $onlyIds: true }).collect()) {
+
+            ids.push(data as _ttid)
+        }
+
+        expect(ids.length).toBe(0)
+    })
+})
+
+describe("SQL", () => {
+
+    test("TRUNCATE", async () => {
+
+        const fylo = new Fylo()
+
+        await fylo.executeSQL<_album>(`CREATE TABLE ${ALBUMS}`)
+
+        await fylo.importBulkData<_album>(ALBUMS, new URL(albumURL))
+
+        await fylo.executeSQL<_album>(`DELETE FROM ${ALBUMS}`)
+
+        const ids = await fylo.executeSQL<_album>(`SELECT _id FROM ${ALBUMS} LIMIT 1`) as _ttid[]
+
+        expect(ids.length).toBe(0)
+    })
+})

package/tests/data.ts

@@ -0,0 +1,110 @@
+function makeDataUrl(data: unknown): string {
+    return `data:application/json,${encodeURIComponent(JSON.stringify(data))}`
+}
+
+function generateAlbums(): _album[] {
+    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(): _post[] {
+    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(): _comment[] {
+    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(): _photo[] {
+    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(): _todo[] {
+    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(): _user[] {
+    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}`
+            }
+        } as unknown as _user
+    })
+}
+
+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/index.ts

@@ -0,0 +1,19 @@
+import { Redis } from '../src/adapters/redis'
+import ttid from '@vyckr/ttid'
+
+const redisPub = new Redis()
+const redisSub = new Redis()
+
+setTimeout(async () => {
+    await redisPub.publish("bun", "insert", ttid.generate())
+}, 2000)
+
+setTimeout(async () => {
+    await redisPub.publish("bun", "insert", ttid.generate())
+}, 3000)
+
+await Bun.sleep(1000)
+
+for await (const data of redisSub.subscribe("bun")) {
+    console.log("Received:", data)
+}

package/tests/integration/create.test.ts

@@ -0,0 +1,57 @@
+import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
+import Fylo from '../../src'
+import { albumURL, postsURL } from '../data'
+import S3Mock from '../mocks/s3'
+import RedisMock from '../mocks/redis'
+
+const POSTS = `post`
+const ALBUMS = `album`
+
+let postsCount = 0
+let albumsCount = 0
+
+const fylo = new Fylo()
+
+mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
+mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
+
+beforeAll(async () => {
+
+    await Promise.all([Fylo.createCollection(POSTS), fylo.executeSQL<_user>(`CREATE TABLE ${ALBUMS}`)])
+    
+    try {
+        albumsCount = await fylo.importBulkData<_album>(ALBUMS, new URL(albumURL), 100)
+        postsCount = await fylo.importBulkData<_post>(POSTS, new URL(postsURL), 100)
+    } catch {
+        await fylo.rollback()
+    }
+})
+
+afterAll(async () => {
+    await Promise.all([Fylo.dropCollection(POSTS), fylo.executeSQL<_album>(`DROP TABLE ${ALBUMS}`)])
+})
+
+describe("NO-SQL", async () => {
+
+    test("PUT", async () => {
+
+        let results: Record<_ttid, _post> = {}
+
+        for await (const data of Fylo.findDocs<_post>(POSTS).collect()) {
+            
+            results = { ...results, ...data as Record<_ttid, _post> }
+        }
+
+        expect(Object.keys(results).length).toEqual(postsCount)
+    })
+})
+
+describe("SQL", () => {
+
+    test("INSERT", async () => {
+
+        const results = await fylo.executeSQL<_album>(`SELECT * FROM ${ALBUMS}`) as Record<_ttid, _album>
+
+        expect(Object.keys(results).length).toEqual(albumsCount)
+    })
+})

package/tests/integration/delete.test.ts

@@ -0,0 +1,147 @@
+import { test, expect, describe, beforeAll, afterAll, mock } from 'bun:test'
+import Fylo from '../../src'
+import { commentsURL, usersURL } from '../data'
+import S3Mock from '../mocks/s3'
+import RedisMock from '../mocks/redis'
+
+const COMMENTS = `comment`
+const USERS = `user`
+
+let commentsResults: Record<_ttid, _comment> = {}
+let usersResults: Record<_ttid, _user> = {}
+
+const fylo = new Fylo()
+
+mock.module('../../src/adapters/s3', () => ({ S3: S3Mock }))
+mock.module('../../src/adapters/redis', () => ({ Redis: RedisMock }))
+
+beforeAll(async () => {
+
+    await Promise.all([
+        Fylo.createCollection(COMMENTS), 
+        fylo.executeSQL<_post>(`CREATE TABLE ${USERS}`)
+    ])
+
+    try {
+        
+        await Promise.all([
+            fylo.importBulkData<_comment>(COMMENTS, new URL(commentsURL), 100),
+            fylo.importBulkData<_user>(USERS, new URL(usersURL), 100)
+        ])
+
+    } catch {
+        await fylo.rollback()
+    }
+
+    for await (const data of Fylo.findDocs<_comment>(COMMENTS, { $limit: 1 }).collect()) {
+
+        commentsResults = { ...commentsResults, ...data as Record<_ttid, _comment> }
+        
+    }
+
+    usersResults = await fylo.executeSQL<_user>(`SELECT * FROM ${USERS} LIMIT 1`) as Record<_ttid, _user>
+})
+
+afterAll(async () => {
+    await Promise.all([Fylo.dropCollection(COMMENTS), fylo.executeSQL<_user>(`DROP TABLE ${USERS}`)])
+})
+
+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<_comment>(COMMENTS).collect()) {
+
+            commentsResults = { ...commentsResults, ...data as Record<_ttid, _comment> }
+        }
+
+        const idx = Object.keys(commentsResults).findIndex(_id => _id === id)
+
+        expect(idx).toEqual(-1)
+
+    })
+
+    test("DELETE CLAUSE", async () => {
+
+        try {
+            await fylo.delDocs<_comment>(COMMENTS, { $ops: [ { name: { $like: "%et%" } } ] })
+            //console.log
+        } catch(e) {
+            console.error(e)
+            await fylo.rollback()
+        }
+        
+        commentsResults = {}
+
+        for await (const data of Fylo.findDocs<_comment>(COMMENTS, { $ops: [ { name: { $like: "%et%" } } ] }).collect()) {
+
+            // console.log(data)
+            
+            commentsResults = { ...commentsResults, ...data as Record<_ttid, _comment> }
+        }
+
+        expect(Object.keys(commentsResults).length).toEqual(0)
+    })
+
+    test("DELETE ALL", async () => {
+
+        try {
+            await fylo.delDocs<_comment>(COMMENTS)
+        } catch {
+            await fylo.rollback()
+        }
+
+        commentsResults = {}
+
+        for await (const data of Fylo.findDocs<_comment>(COMMENTS).collect()) {
+
+            commentsResults = { ...commentsResults, ...data as Record<_ttid, _comment> }
+        }
+
+        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<_user>(`DELETE FROM ${USERS} WHERE name = '${name}'`)
+        } catch {
+            await fylo.rollback()
+        } 
+
+        usersResults = await fylo.executeSQL<_user>(`SELECT * FROM ${USERS} WHERE name = '${name}'`) as Record<_ttid, _user>
+        
+        const idx = Object.values(usersResults).findIndex(com => com.name === name)
+
+        expect(idx).toBe(-1)
+    })
+
+    test("DELETE ALL", async () => {
+
+        try {
+            await fylo.executeSQL<_user>(`DELETE FROM ${USERS}`)
+        } catch {
+            await fylo.rollback()
+        }
+
+        usersResults = await fylo.executeSQL<_user>(`SELECT * FROM ${USERS}`) as Record<_ttid, _user>
+
+        expect(Object.keys(usersResults).length).toBe(0)
+    })
+})