mtrl 0.0.0

package/src/core/collection/adapters/mongodb.js

@@ -0,0 +1,232 @@
+// src/core/collection/adapters/mongodb.js
+
+import { MongoClient, ObjectId } from 'mongodb'
+import { OPERATORS, createBaseAdapter } from './base'
+
+const MONGODB_OPERATORS = {
+  [OPERATORS.EQ]: '$eq',
+  [OPERATORS.NE]: '$ne',
+  [OPERATORS.GT]: '$gt',
+  [OPERATORS.GTE]: '$gte',
+  [OPERATORS.LT]: '$lt',
+  [OPERATORS.LTE]: '$lte',
+  [OPERATORS.IN]: '$in',
+  [OPERATORS.NIN]: '$nin',
+  [OPERATORS.CONTAINS]: '$regex',
+  [OPERATORS.STARTS_WITH]: '$regex',
+  [OPERATORS.ENDS_WITH]: '$regex'
+}
+
+export const createMongoAdapter = (config = {}) => {
+  const base = createBaseAdapter(config)
+  let client = null
+  let db = null
+  let collection = null
+
+  const transformDocument = (doc) => {
+    if (!doc) return null
+    const { _id, ...rest } = doc
+    return { id: _id.toString(), ...rest }
+  }
+
+  const transformForMongo = (doc) => {
+    if (!doc) return null
+    const { id, ...rest } = doc
+    return { _id: id ? new ObjectId(id) : new ObjectId(), ...rest }
+  }
+
+  const transformQuery = (query) => {
+    const transformed = {}
+
+    Object.entries(query).forEach(([field, conditions]) => {
+      if (typeof conditions === 'object') {
+        transformed[field] = Object.entries(conditions).reduce((acc, [op, value]) => {
+          const mongoOp = MONGODB_OPERATORS[op]
+          if (!mongoOp) return acc
+
+          if (op === OPERATORS.CONTAINS) {
+            acc[mongoOp] = new RegExp(value, 'i')
+          } else if (op === OPERATORS.STARTS_WITH) {
+            acc[mongoOp] = new RegExp(`^${value}`, 'i')
+          } else if (op === OPERATORS.ENDS_WITH) {
+            acc[mongoOp] = new RegExp(`${value}$`, 'i')
+          } else {
+            acc[mongoOp] = value
+          }
+
+          return acc
+        }, {})
+      } else {
+        transformed[field] = conditions
+      }
+    })
+
+    return transformed
+  }
+
+  return {
+    ...base,
+
+    connect: async () => {
+      try {
+        client = new MongoClient(config.uri, {
+          useUnifiedTopology: true,
+          maxPoolSize: 10,
+          ...config.options
+        })
+
+        await client.connect()
+        db = client.db(config.dbName)
+        collection = db.collection(config.collection)
+
+        // Optional: Create indexes
+        // await collection.createIndex({ field: 1 })
+      } catch (error) {
+        return base.handleError(new Error(`MongoDB connection failed: ${error.message}`))
+      }
+    },
+
+    disconnect: async () => {
+      if (client) {
+        await client.close()
+        client = null
+        db = null
+        collection = null
+      }
+    },
+
+    create: async (items) => {
+      if (!collection) {
+        return base.handleError(new Error('Not connected to MongoDB'))
+      }
+
+      const docs = items.map(item => transformForMongo(item))
+      const result = await collection.insertMany(docs)
+
+      return items.map((item, index) => ({
+        ...item,
+        id: result.insertedIds[index].toString()
+      }))
+    },
+
+    read: async (query = {}, options = {}) => {
+      if (!collection) {
+        return base.handleError(new Error('Not connected to MongoDB'))
+      }
+
+      const {
+        skip = 0,
+        limit = 0,
+        sort = {},
+        projection = {}
+      } = options
+
+      const mongoQuery = transformQuery(query)
+
+      const cursor = collection
+        .find(mongoQuery)
+        .skip(skip)
+        .limit(limit)
+        .project(projection)
+        .sort(sort)
+
+      const docs = await cursor.toArray()
+      return docs.map(doc => transformDocument(doc))
+    },
+
+    update: async (items) => {
+      if (!collection) {
+        return base.handleError(new Error('Not connected to MongoDB'))
+      }
+
+      const operations = items.map(item => ({
+        updateOne: {
+          filter: { _id: new ObjectId(item.id) },
+          update: { $set: transformForMongo(item) },
+          upsert: false
+        }
+      }))
+
+      await collection.bulkWrite(operations)
+      return items
+    },
+
+    delete: async (ids) => {
+      if (!collection) {
+        return base.handleError(new Error('Not connected to MongoDB'))
+      }
+
+      const mongoIds = ids.map(id => new ObjectId(id))
+      await collection.deleteMany({ _id: { $in: mongoIds } })
+      return ids
+    },
+
+    query: async (query = {}, options = {}) => {
+      if (!collection) {
+        return base.handleError(new Error('Not connected to MongoDB'))
+      }
+
+      const {
+        pipeline = [],
+        skip = 0,
+        limit = 0
+      } = options
+
+      const mongoQuery = transformQuery(query)
+
+      const aggregation = [
+        { $match: mongoQuery },
+        ...pipeline
+      ]
+
+      if (skip > 0) {
+        aggregation.push({ $skip: skip })
+      }
+
+      if (limit > 0) {
+        aggregation.push({ $limit: limit })
+      }
+
+      const docs = await collection.aggregate(aggregation).toArray()
+
+      return {
+        results: docs.map(doc => transformDocument(doc)),
+        total: await collection.countDocuments(mongoQuery)
+      }
+    },
+
+    watch: (callback, pipeline = []) => {
+      if (!collection) {
+        return base.handleError(new Error('Not connected to MongoDB'))
+      }
+
+      const changeStream = collection.watch(pipeline, {
+        fullDocument: 'updateLookup'
+      })
+
+      changeStream.on('change', async (change) => {
+        const { operationType, documentKey, fullDocument } = change
+
+        switch (operationType) {
+          case 'insert':
+          case 'update':
+          case 'replace':
+            callback({
+              type: operationType,
+              document: transformDocument(fullDocument)
+            })
+            break
+
+          case 'delete':
+            callback({
+              type: operationType,
+              documentId: documentKey._id.toString()
+            })
+            break
+        }
+      })
+
+      return () => changeStream.close()
+    }
+  }
+}

package/src/core/collection/adapters/route.js

@@ -0,0 +1,201 @@
+// src/core/collection/adapters/route.js
+
+import { OPERATORS, createBaseAdapter } from './base'
+
+const QUERY_PARAMS = {
+  [OPERATORS.EQ]: 'eq',
+  [OPERATORS.NE]: 'ne',
+  [OPERATORS.GT]: 'gt',
+  [OPERATORS.GTE]: 'gte',
+  [OPERATORS.LT]: 'lt',
+  [OPERATORS.LTE]: 'lte',
+  [OPERATORS.IN]: 'in',
+  [OPERATORS.NIN]: 'nin',
+  [OPERATORS.CONTAINS]: 'contains',
+  [OPERATORS.STARTS_WITH]: 'startsWith',
+  [OPERATORS.ENDS_WITH]: 'endsWith'
+}
+
+export const createRouteAdapter = (config = {}) => {
+  const base = createBaseAdapter(config)
+  let controller = null
+  const cache = new Map()
+
+  const buildUrl = (endpoint, params = {}) => {
+    const url = new URL(config.base + endpoint)
+    Object.entries(params).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach(v => url.searchParams.append(key, v))
+      } else if (value !== null && value !== undefined) {
+        url.searchParams.append(key, value)
+      }
+    })
+    return url.toString()
+  }
+
+  const transformQuery = (query) => {
+    const params = {}
+    Object.entries(query).forEach(([field, conditions]) => {
+      if (typeof conditions === 'object') {
+        Object.entries(conditions).forEach(([op, value]) => {
+          const paramKey = QUERY_PARAMS[op]
+          if (paramKey) {
+            params[`${field}_${paramKey}`] = value
+          }
+        })
+      } else {
+        params[field] = conditions
+      }
+    })
+    return params
+  }
+
+  const request = async (url, options = {}) => {
+    if (controller) {
+      controller.abort()
+    }
+    controller = new AbortController()
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          'Content-Type': 'application/json',
+          ...config.headers,
+          ...options.headers
+        },
+        signal: controller.signal
+      })
+
+      if (!response.ok) {
+        const error = await response.json()
+        return base.handleError(new Error(error.message || 'API request failed'))
+      }
+
+      return await response.json()
+    } catch (error) {
+      if (error.name === 'AbortError') return null
+      return base.handleError(error)
+    } finally {
+      controller = null
+    }
+  }
+
+  const getCache = (key) => {
+    if (!config.cache) return null
+
+    const cached = cache.get(key)
+    if (!cached) return null
+
+    const { data, timestamp } = cached
+    const now = Date.now()
+
+    if (now - timestamp > 5 * 60 * 1000) {
+      cache.delete(key)
+      return null
+    }
+
+    return data
+  }
+
+  const setCache = (key, data) => {
+    if (!config.cache) return
+    cache.set(key, { data, timestamp: Date.now() })
+  }
+
+  return {
+    ...base,
+
+    create: async (items) => {
+      const url = buildUrl(config.endpoints.create)
+      const response = await request(url, {
+        method: 'POST',
+        body: JSON.stringify({ items })
+      })
+      return response.items
+    },
+
+    read: async (query = {}, options = {}) => {
+      const {
+        page = 1,
+        limit = 20,
+        sort,
+        fields
+      } = options
+
+      const params = {
+        ...transformQuery(query),
+        page,
+        limit,
+        sort,
+        fields
+      }
+
+      const url = buildUrl(config.endpoints.list, params)
+      const cacheKey = url.toString()
+
+      const cached = getCache(cacheKey)
+      if (cached) return cached
+
+      const response = await request(url)
+      setCache(cacheKey, response.items)
+
+      return response.items
+    },
+
+    update: async (items) => {
+      const url = buildUrl(config.endpoints.update)
+      const response = await request(url, {
+        method: 'PUT',
+        body: JSON.stringify({ items })
+      })
+      return response.items
+    },
+
+    delete: async (ids) => {
+      const url = buildUrl(config.endpoints.delete)
+      const response = await request(url, {
+        method: 'DELETE',
+        body: JSON.stringify({ ids })
+      })
+      return response.ids
+    },
+
+    query: async (query = {}, options = {}) => {
+      const {
+        page = 1,
+        limit = 20,
+        sort,
+        fields,
+        ...rest
+      } = options
+
+      const params = {
+        ...transformQuery(query),
+        ...rest,
+        page,
+        limit,
+        sort,
+        fields
+      }
+
+      const url = buildUrl(config.endpoints.list, params)
+      const response = await request(url)
+
+      return {
+        items: response.items,
+        total: response.total,
+        page: response.page,
+        pages: response.pages
+      }
+    },
+
+    disconnect: () => {
+      if (controller) {
+        controller.abort()
+        controller = null
+      }
+      cache.clear()
+    }
+  }
+}

package/src/core/collection/collection.js

@@ -0,0 +1,259 @@
+// src/core/collection/collection.js
+
+/**
+ * Event types for collection changes
+ */
+export const COLLECTION_EVENTS = {
+  CHANGE: 'change',
+  ADD: 'add',
+  UPDATE: 'update',
+  REMOVE: 'remove',
+  ERROR: 'error',
+  LOADING: 'loading'
+}
+
+/**
+ * Query operators for filtering
+ */
+export const OPERATORS = {
+  EQ: 'eq',
+  NE: 'ne',
+  GT: 'gt',
+  GTE: 'gte',
+  LT: 'lt',
+  LTE: 'lte',
+  IN: 'in',
+  NIN: 'nin',
+  CONTAINS: 'contains',
+  STARTS_WITH: 'startsWith',
+  ENDS_WITH: 'endsWith'
+}
+
+/**
+ * Base Collection class providing data management interface
+ * @template T - Type of items in collection
+ */
+export class Collection {
+  #items = new Map()
+  #observers = new Set()
+  #query = null
+  #sort = null
+  #loading = false
+  #error = null
+
+  /**
+   * Creates a new collection instance
+   * @param {Object} config - Collection configuration
+   * @param {Function} config.transform - Transform function for items
+   * @param {Function} config.validate - Validation function for items
+   */
+  constructor (config = {}) {
+    this.transform = config.transform || (item => item)
+    this.validate = config.validate || (() => true)
+  }
+
+  /**
+   * Subscribe to collection changes
+   * @param {Function} observer - Observer callback
+   * @returns {Function} Unsubscribe function
+   */
+  subscribe (observer) {
+    this.#observers.add(observer)
+    return () => this.#observers.delete(observer)
+  }
+
+  /**
+   * Notify observers of collection changes
+   * @param {string} event - Event type
+   * @param {*} data - Event data
+   */
+  #notify (event, data) {
+    this.#observers.forEach(observer => observer({ event, data }))
+  }
+
+  /**
+   * Set loading state
+   * @param {boolean} loading - Loading state
+   */
+  #setLoading (loading) {
+    this.#loading = loading
+    this.#notify(COLLECTION_EVENTS.LOADING, loading)
+  }
+
+  /**
+   * Set error state
+   * @param {Error} error - Error object
+   */
+  #setError (error) {
+    this.#error = error
+    this.#notify(COLLECTION_EVENTS.ERROR, error)
+  }
+
+  /**
+   * Get collection items based on current query and sort
+   * @returns {Array<T>} Collection items
+   */
+  get items () {
+    let result = Array.from(this.#items.values())
+
+    if (this.#query) {
+      result = result.filter(this.#query)
+    }
+
+    if (this.#sort) {
+      result.sort(this.#sort)
+    }
+
+    return result
+  }
+
+  /**
+   * Get collection size
+   * @returns {number} Number of items
+   */
+  get size () {
+    return this.#items.size
+  }
+
+  /**
+   * Get loading state
+   * @returns {boolean} Loading state
+   */
+  get loading () {
+    return this.#loading
+  }
+
+  /**
+   * Get error state
+   * @returns {Error|null} Error object
+   */
+  get error () {
+    return this.#error
+  }
+
+  /**
+   * Set query filter
+   * @param {Function} queryFn - Query function
+   */
+  query (queryFn) {
+    this.#query = queryFn
+    this.#notify(COLLECTION_EVENTS.CHANGE, this.items)
+  }
+
+  /**
+   * Set sort function
+   * @param {Function} sortFn - Sort function
+   */
+  sort (sortFn) {
+    this.#sort = sortFn
+    this.#notify(COLLECTION_EVENTS.CHANGE, this.items)
+  }
+
+  /**
+   * Add items to collection
+   * @param {T|Array<T>} items - Items to add
+   * @returns {Promise<Array<T>>} Added items
+   */
+  async add (items) {
+    try {
+      this.#setLoading(true)
+      const toAdd = Array.isArray(items) ? items : [items]
+
+      const validated = toAdd.filter(this.validate)
+      const transformed = validated.map(this.transform)
+
+      transformed.forEach(item => {
+        if (!item.id) {
+          throw new Error('Items must have an id property')
+        }
+        this.#items.set(item.id, item)
+      })
+
+      this.#notify(COLLECTION_EVENTS.ADD, transformed)
+      this.#notify(COLLECTION_EVENTS.CHANGE, this.items)
+
+      return transformed
+    } catch (error) {
+      this.#setError(error)
+      throw error
+    } finally {
+      this.#setLoading(false)
+    }
+  }
+
+  /**
+   * Update items in collection
+   * @param {T|Array<T>} items - Items to update
+   * @returns {Promise<Array<T>>} Updated items
+   */
+  async update (items) {
+    try {
+      this.#setLoading(true)
+      const toUpdate = Array.isArray(items) ? items : [items]
+
+      const updated = toUpdate.map(item => {
+        if (!this.#items.has(item.id)) {
+          throw new Error(`Item with id ${item.id} not found`)
+        }
+
+        const validated = this.validate(item)
+        if (!validated) {
+          throw new Error(`Invalid item: ${item.id}`)
+        }
+
+        const transformed = this.transform(item)
+        this.#items.set(item.id, transformed)
+        return transformed
+      })
+
+      this.#notify(COLLECTION_EVENTS.UPDATE, updated)
+      this.#notify(COLLECTION_EVENTS.CHANGE, this.items)
+
+      return updated
+    } catch (error) {
+      this.#setError(error)
+      throw error
+    } finally {
+      this.#setLoading(false)
+    }
+  }
+
+  /**
+   * Remove items from collection
+   * @param {string|Array<string>} ids - Item IDs to remove
+   * @returns {Promise<Array<string>>} Removed item IDs
+   */
+  async remove (ids) {
+    try {
+      this.#setLoading(true)
+      const toRemove = Array.isArray(ids) ? ids : [ids]
+
+      toRemove.forEach(id => {
+        if (!this.#items.has(id)) {
+          throw new Error(`Item with id ${id} not found`)
+        }
+        this.#items.delete(id)
+      })
+
+      this.#notify(COLLECTION_EVENTS.REMOVE, toRemove)
+      this.#notify(COLLECTION_EVENTS.CHANGE, this.items)
+
+      return toRemove
+    } catch (error) {
+      this.#setError(error)
+      throw error
+    } finally {
+      this.#setLoading(false)
+    }
+  }
+
+  /**
+   * Clear all items from collection
+   */
+  clear () {
+    this.#items.clear()
+    this.#query = null
+    this.#sort = null
+    this.#notify(COLLECTION_EVENTS.CHANGE, this.items)
+  }
+}