asasvirtuais 0.1.0

package/packages/replit-db.ts

@@ -0,0 +1,219 @@
+import { DatabaseInterface, TableInterface, Query } from './crud'
+import z from 'zod'
+import { feathers } from '@feathersjs/feathers'
+import { KnexService } from '@feathersjs/knex'
+import knex from 'knex'
+
+if (!process.env.DATABASE_URL) {
+  throw new Error(
+    "DATABASE_URL must be set. Did you forget to provision a database?",
+  )
+}
+
+// Initialize Knex with PostgreSQL connection
+const db = knex({
+  client: 'pg',
+  connection: process.env.DATABASE_URL,
+  pool: {
+    min: 2,
+    max: 10
+  }
+})
+
+// Initialize FeathersJS app
+const app = feathers()
+
+// Cache for FeathersJS services to avoid recreation
+const serviceCache = new Map<string, KnexService>()
+
+// Ensure table exists in the database
+async function ensureTableExists(tableName: string) {
+  try {
+    const exists = await db.schema.hasTable(tableName)
+    if (!exists) {
+      await db.schema.createTable(tableName, (table) => {
+        table.uuid('id').primary().defaultTo(db.raw('gen_random_uuid()'))
+        table.jsonb('data').notNullable()
+        table.timestamp('created_at').defaultTo(db.fn.now())
+        table.timestamp('updated_at').defaultTo(db.fn.now())
+      })
+      console.log(`[REPLIT-DB] Created table ${tableName}`)
+    }
+  } catch (error) {
+    console.warn(`[REPLIT-DB] Could not ensure table ${tableName} exists:`, error)
+  }
+}
+
+// Get or create FeathersJS service for a table
+function getService(tableName: string): KnexService {
+  if (!serviceCache.has(tableName)) {
+    const service = new KnexService({
+      Model: db,
+      name: tableName,
+      id: 'id',
+      paginate: false // Disable pagination for simpler API
+    })
+    serviceCache.set(tableName, service)
+    app.use(tableName, service)
+  }
+  return serviceCache.get(tableName)!
+}
+
+export function replitDbInterface<Schema extends DatabaseInterface, T extends keyof Schema & string>(defaultTable?: T): TableInterface<z.infer<Schema[T]['readable']>, z.infer<Schema[T]['writable']>> {
+  type Readable = z.infer<Schema[T]['readable']>
+  type Writable = z.infer<Schema[T]['writable']>
+  
+  return {
+    async find({ table = defaultTable, id }) {
+      const tableName = table as string
+      await ensureTableExists(tableName)
+      const service = getService(tableName)
+      
+      try {
+        const result = await service.get(id)
+        return { id: result.id, ...result.data } as Readable
+      } catch (error) {
+        throw new Error(`Record not found in ${tableName} with id ${id}`)
+      }
+    },
+
+    async list({ table = defaultTable, query: q = {} }) {
+      const tableName = table as string
+      await ensureTableExists(tableName)
+      
+      // Build the query using Knex directly for proper JSONB handling
+      let knexQuery = db.select('*').from(tableName)
+      
+      if (q) {
+        // Handle meta operators
+        if (q.$limit) {
+          knexQuery = knexQuery.limit(q.$limit)
+        }
+        if (q.$skip) {
+          knexQuery = knexQuery.offset(q.$skip)
+        }
+        if (q.$sort) {
+          for (const [field, direction] of Object.entries(q.$sort)) {
+            const order = direction === 1 ? 'asc' : 'desc'
+            knexQuery = knexQuery.orderByRaw(`data->>'${field}' ${order}`)
+          }
+        }
+        
+        // Apply all conditions using a recursive function
+        knexQuery = applyConditions(knexQuery, q)
+      }
+      
+      const results = await knexQuery
+      return results.map(row => ({ id: row.id, ...row.data } as unknown as Readable))
+    },
+
+    async create({ table = defaultTable, data }) {
+      const tableName = table as string
+      await ensureTableExists(tableName)
+      const service = getService(tableName)
+      
+      const result = await service.create({
+        data: data as any,
+      })
+      
+      console.log(`[REPLIT-DB] Record created in ${tableName} with id ${result.id}`)
+      return { id: result.id, ...data } as Readable
+    },
+
+    async update({ table = defaultTable, id, data }) {
+      const tableName = table as string
+      await ensureTableExists(tableName)
+      const service = getService(tableName)
+      
+      // Get current record to merge data
+      const current = await service.get(id)
+      const mergedData = { ...current.data, ...data }
+      
+      const result = await service.patch(id, {
+        data: mergedData,
+        updated_at: new Date()
+      })
+      
+      console.log(`[REPLIT-DB] Record updated in ${tableName} with id ${id}`)
+      return { id: result.id, ...result.data } as Readable
+    },
+
+    async remove({ table = defaultTable, id }) {
+      const tableName = table as string
+      await ensureTableExists(tableName)
+      const service = getService(tableName)
+      
+      // Get the record before deletion
+      const current = await service.get(id)
+      const data = { id: current.id, ...current.data } as Readable
+      
+      await service.remove(id)
+      
+      console.log(`[REPLIT-DB] Record removed from ${tableName} with id ${id}`)
+      return data
+    },
+  }
+}
+
+// Recursive function to apply query conditions with proper operator handling
+function applyConditions(query: any, conditions: any): any {
+  for (const [key, value] of Object.entries(conditions)) {
+    if (key.startsWith('$')) {
+      // Handle compound operators
+      if (key === '$or' && Array.isArray(value)) {
+        query = query.where(function() {
+          for (const orCondition of value) {
+            this.orWhere(function() {
+              applyConditions(this, orCondition)
+            })
+          }
+        })
+      } else if (key === '$and' && Array.isArray(value)) {
+        for (const andCondition of value) {
+          query = query.where(function() {
+            applyConditions(this, andCondition)
+          })
+        }
+      }
+      // Skip other meta operators like $limit, $skip, $sort - they're handled elsewhere
+    } else {
+      // Handle field conditions
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        // Handle operators like $ne, $in, etc.
+        for (const [op, opValue] of Object.entries(value)) {
+          switch (op) {
+            case '$ne':
+              query = query.whereRaw(`data->>'${key}' != ?`, [opValue])
+              break
+            case '$in':
+              if (Array.isArray(opValue)) {
+                query = query.whereRaw(`data->>'${key}' = ANY(?)`, [opValue])
+              }
+              break
+            case '$nin':
+              if (Array.isArray(opValue)) {
+                query = query.whereRaw(`data->>'${key}' != ALL(?)`, [opValue])
+              }
+              break
+            case '$lt':
+              query = query.whereRaw(`(data->>'${key}')::numeric < ?`, [opValue])
+              break
+            case '$lte':
+              query = query.whereRaw(`(data->>'${key}')::numeric <= ?`, [opValue])
+              break
+            case '$gt':
+              query = query.whereRaw(`(data->>'${key}')::numeric > ?`, [opValue])
+              break
+            case '$gte':
+              query = query.whereRaw(`(data->>'${key}')::numeric >= ?`, [opValue])
+              break
+          }
+        }
+      } else {
+        // Simple equality
+        query = query.whereRaw(`data->>'${key}' = ?`, [value])
+      }
+    }
+  }
+  return query
+}

package/packages/wretch.ts

@@ -0,0 +1,22 @@
+import { FetchLike } from 'wretch'
+
+export function ratePerSec(max: number, delay: number = 1000) {
+    let count : number = 0
+
+    return (next: FetchLike) => {
+
+        const check: FetchLike = async (url, opts) => {
+            if (count < max) {
+                count++
+                try {
+                    return await next(url, opts)
+                } finally {
+                    setTimeout(() => count--, delay)
+                }
+            } else {
+                return new Promise((resolve) => setTimeout(() => resolve(check(url, opts)), delay))
+            }
+        }
+        return check
+    }
+}

package/packages/yaml.ts

@@ -0,0 +1,163 @@
+import fs from 'fs'
+import { writeFile } from 'fs/promises'
+import YAML from 'yaml'
+import { generateId } from 'ai'
+import { DatabaseInterface, TableInterface } from './crud'
+import z from 'zod'
+
+export class Mutex {
+  private promise : Promise<any> = Promise.resolve()
+  
+  async run<T>(fn: () => Promise<T>): Promise<T> {
+    const result = this.promise.then(fn)
+    this.promise = result.catch(() => {}) // Don't break chain on errors
+    return result
+  }
+}
+
+export const fileMutex = new Mutex()
+
+export function yamlInterface<Schema extends DatabaseInterface, T extends keyof Schema & string>(defaultTable: string, databasePath = 'database'): TableInterface<z.infer<Schema[T]['readable']>, z.infer<Schema[T]['writable']>>{
+    type Readable = z.infer<Schema[T]['readable']>
+    type Writable = z.infer<Schema[T]['writable']>
+    const tablePath = (name: string) => `${databasePath}/${name}`
+    const recordPath = (table: string, id: string) => `${tablePath(table)}/${id}.yaml`
+    const readRecord = (table: string, id: string) => {
+        const path = recordPath(table, id)
+        if ( ! fs.existsSync(path) )
+            throw new Error(`Record not found: ${path}`)
+        const file = fs.readFileSync(path, 'utf8')
+        return YAML.parse(file) as Readable
+    }
+    return {
+        async find({ table = defaultTable, id }) {
+            return readRecord(table as string, id)
+        },
+        async list({ table = defaultTable, query }) {
+            const path = tablePath(table as string)
+            if (!fs.existsSync(path)) {
+                // If the table directory doesn't exist, return an empty array.
+                return []
+            }
+            const files = fs.readdirSync(path)
+            let records: Readable[] = []
+            for (const file of files) {
+                if (file.endsWith('.yaml')) {
+                    const id = file.slice(0, -5)
+                    try {
+                        const record = readRecord(table, id)
+                        records.push(record)
+                    } catch (error) {
+                        console.error(`Error reading record ${id} from table ${table}:`, error)
+                    }
+                }
+            }
+
+            if (query) {
+                const { $limit, $skip, $sort, $select, ...filters } = query
+
+                // Apply filters
+                if (Object.keys(filters).length > 0) {
+                    records = records.filter(record => {
+                    return Object.entries(filters).every(([key, value]) => {
+                        const recordValue = record[key as keyof typeof record]
+                        if (typeof value === 'object' && value !== null) {
+                            // Handle operators within a field
+                            return Object.entries(value).every(([op, opValue]) => {
+                                switch (op) {
+                                    case '$ne':
+                                        return recordValue != opValue
+                                    case '$in':
+                                        return Array.isArray(opValue) && opValue.includes(recordValue)
+                                    case '$nin':
+                                        return Array.isArray(opValue) && !opValue.includes(recordValue)
+                                    case '$lt':
+                                        // @ts-expect-error
+                                        return recordValue < opValue
+                                    case '$lte':
+                                        // @ts-expect-error
+                                        return recordValue <= opValue
+                                    case '$gt':
+                                        // @ts-expect-error
+                                        return recordValue > opValue
+                                    case '$gte':
+                                        // @ts-expect-error
+                                        return recordValue >= opValue
+                                    case '$search':
+                                        return typeof recordValue === 'string' && recordValue.toLowerCase().includes(String(opValue).toLowerCase())
+                                    default:
+                                        return true // Unknown operators are ignored
+                                }
+                            })
+                        }
+                        return recordValue === value
+                    })
+                })
+                }
+                
+                // Apply sorting
+                if ($sort) {
+                    const sortKeys = Object.keys($sort) as (keyof Readable)[]
+                    if (sortKeys.length > 0) {
+                        const key = sortKeys[0]
+                        const direction = $sort[key] === 1 ? 1 : -1
+                        records.sort((a, b) => {
+                            if (a[key] < b[key]) return -1 * direction
+                            if (a[key] > b[key]) return 1 * direction
+                            return 0
+                        })
+                    }
+                }
+
+                // Apply pagination
+                const skip = $skip || 0
+                const limit = $limit || records.length
+                records = records.slice(skip, skip + limit)
+
+                // Apply projection
+                if ($select) {
+                    records = records.map(record => {
+                        // @ts-expect-error
+                        const selectedRecord: Partial<Readable> = { id: (record).id }
+                        // @ts-expect-error
+                        ($select as (keyof Readable)[]).forEach(key => {
+                            // @ts-expect-error
+                            selectedRecord[key] = record[key]
+                        })
+                        return selectedRecord as Readable
+                    })
+                }
+            }
+
+            return records
+        },
+        async create({table = defaultTable, ...props}) {
+            props.data
+            const path = tablePath(table as string)
+            if ( ! fs.existsSync(path ) )
+                fs.mkdirSync(path, { recursive: true })
+            const id = generateId()
+            const record = { id, ...props.data }
+            const filePath = recordPath(table as string, id)
+            await fileMutex.run(() => writeFile(filePath, YAML.stringify(record), 'utf8'))
+            return record as Readable
+        },
+        async update({table = defaultTable, id, ...props}) {
+            const record = readRecord(table as string, id)
+            const updatedRecord = { ...record, ...props.data }
+            await fileMutex.run(() => writeFile(recordPath(table as string, id), YAML.stringify(updatedRecord), 'utf8'))
+            return updatedRecord as Readable
+        },
+        async remove({table = defaultTable, id}) {
+            const path = recordPath(table as string, id)
+            const data = readRecord(table as string, id)
+            if ( ! fs.existsSync(path) )
+                throw new Error(`Record not found: ${path}`)
+            fs.unlinkSync(path)
+            return {
+                id,
+                ...data
+            }
+        },
+    }
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,4 @@
+packages:
+  - 'packages/*'
+  - 'app'
+  - 'server'

package/server/db.ts

@@ -0,0 +1,15 @@
+import { Pool, neonConfig } from '@neondatabase/serverless';
+import { drizzle } from 'drizzle-orm/neon-serverless';
+import ws from "ws";
+import * as schema from "@shared/schema";
+
+neonConfig.webSocketConstructor = ws;
+
+if (!process.env.DATABASE_URL) {
+  throw new Error(
+    "DATABASE_URL must be set. Did you forget to provision a database?",
+  );
+}
+
+export const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+export const db = drizzle({ client: pool, schema });