@cero-base/core 0.2.0 → 0.4.0

package/src/lib/collection.js

@@ -1,252 +0,0 @@
-import { Readable } from 'streamx'
-import { randomId } from './crypto.js'
-import { debounce, isLocal, isPrivate } from './utils.js'
-import { SCOPE_LOCAL } from './constants.js'
-
-/** Route a write operation based on scope */
-function writeOp(owner, scope, path, ns, op, data, isDel) {
-  if (isLocal(scope)) {
-    const method = isDel ? 'delete' : 'insert'
-    return owner.local[method](path, data).then(() => owner.emit('update'))
-  }
-  const target = isPrivate(scope) ? owner.identity : owner.room
-  return target.dispatch(`${ns}/${op}`, data)
-}
-
-/**
- * Collection — 4 verbs: put, get, del, sub
- *
- * @example
- * const tasks = room.collection('tasks')
- *
- * await tasks.put({ text: 'Buy milk', done: false })
- * await tasks.get()                       // all docs
- * await tasks.get({ done: false })        // filtered
- * await tasks.del({ id: 'abc' })
- * tasks.sub().on('data', cb)
- */
-export class Collection {
-  constructor(owner, name, opts = {}) {
-    this.owner = owner
-    this.schema = owner.schema
-    this.name = name
-
-    if (opts.local) {
-      // Forced local resolution — used by db.local.collection(name) to reach
-      // cero's local-scope built-ins (rooms cache, files, etc.) and user-
-      // declared `scope: 'local'` collections via the same accessor.
-      const type = this.schema.localTypeOf(name)
-      if (!type) throw new Error(`'${name}' is not a local collection`)
-      this.scope = SCOPE_LOCAL
-      this.type = type
-      this.keys = this.schema.localKeysOf(name)
-      this.path = `@local/${name}`
-      this.ns = '@local'
-      this.hasAdd = true // local merges via direct insert; no dispatch involved
-      this.timestamps = false
-      this.counter = false
-      this.indexes = null
-      return
-    }
-
-    const def = this.schema.collections[name]
-    this.scope = this.schema.getScope(name)
-    this.type = this.schema.types.get(name)
-    this.path = this.schema.getPath(name)
-    this.ns = this.path.split('/')[0]
-    this.keys = this.schema.keysOf(name)
-    this.hasAdd = this.schema.hasAdd(name)
-    this.timestamps = this.schema.hasTimestamps(name)
-    this.counter = !isLocal(this.scope) // all non-local collections have counter
-    this.indexes = def?.indexes || null
-  }
-
-  get db() {
-    if (isLocal(this.scope)) return null
-    return isPrivate(this.scope) ? this.owner.identity.db : this.owner.room.db
-  }
-
-  /** Upsert — insert if new, update if exists */
-  async put(doc) {
-    const isNew = !doc.id
-    const data = isNew ? { ...doc, id: randomId() } : doc
-
-    // If cero doesn't have add-${type} for this built-in (profile, settings),
-    // there's no auto-incrementing index — set-${type} is the only path and
-    // is itself an idempotent upsert.
-    if (!this.hasAdd) {
-      return this._write(`set-${this.type}`, data)
-    }
-
-    // Freshly randomized id can't possibly exist — skip the lookup.
-    const existing = isNew
-      ? null
-      : await this._getOne(this.keys.reduce((acc, k) => ((acc[k] = data[k]), acc), {}))
-
-    if (existing) {
-      const updated = { ...existing, ...data }
-      if (this.timestamps) updated.updatedAt = Date.now()
-      return this._write(`set-${this.type}`, updated)
-    }
-
-    if (this.timestamps) data.createdAt = data.createdAt ?? Date.now()
-    return this._write(`add-${this.type}`, data)
-  }
-
-  /** Get docs — no query returns all, query filters, supports range queries on index */
-  async get(query = {}, opts = {}) {
-    if (isLocal(this.scope)) {
-      const all = await this.owner.local.find(this.path, opts)
-      return filter(all, query)
-    }
-
-    if (
-      this.counter &&
-      (typeof query.gte === 'number' ||
-        typeof query.lte === 'number' ||
-        typeof query.gt === 'number' ||
-        typeof query.lt === 'number')
-    ) {
-      return this._rangeByIndex(query, opts)
-    }
-
-    return findDocs(this.db, this.path, this.indexes, this.name, query, opts)
-  }
-
-  /** Get count */
-  async count() {
-    if (!this.counter) return (await this.get()).length
-
-    const counterPath = `${this.ns}/counters`
-    const snapshot = this.db.snapshot()
-    try {
-      const counter = await snapshot.get(counterPath, { name: this.name })
-      return counter?.value || 0
-    } finally {
-      await snapshot.close()
-    }
-  }
-
-  /** @private Range query on index field via the by-index index */
-  async _rangeByIndex(query, opts = {}) {
-    const indexPath = `${this.path}-by-index`
-    const snapshot = this.db.snapshot()
-    try {
-      const rangeQuery = {}
-      if (query.gte !== undefined) rangeQuery.gte = { index: query.gte }
-      if (query.lte !== undefined) rangeQuery.lte = { index: query.lte }
-      if (query.gt !== undefined) rangeQuery.gt = { index: query.gt }
-      if (query.lt !== undefined) rangeQuery.lt = { index: query.lt }
-      return snapshot.find(indexPath, { ...rangeQuery, ...opts }).toArray()
-    } finally {
-      await snapshot.close()
-    }
-  }
-
-  /** Delete a document by query */
-  async del(query) {
-    const [existing] = await this.get(query)
-    if (!existing) return false
-
-    const keyData = this.keys.reduce((acc, k) => ((acc[k] = existing[k]), acc), {})
-    await this._write(`del-${this.type}`, keyData, true)
-    return true
-  }
-
-  /** Dispatch a custom op (registered via the schema's handlers) on this collection */
-  async dispatch(op, data) {
-    if (isLocal(this.scope)) {
-      throw new Error(`Cannot dispatch on local collection '${this.name}'`)
-    }
-    const target = isPrivate(this.scope) ? this.owner.identity : this.owner.room
-    return target.dispatch(`${this.ns}/${op}`, data)
-  }
-
-  /** Subscribe — returns Readable stream of query results */
-  sub(query = {}, opts = {}) {
-    const stream = new Readable()
-    const emitter = this.owner
-
-    const refresh = debounce(async () => {
-      try {
-        const results = await this.get(query, opts)
-        stream.push(results)
-      } catch (err) {
-        stream.destroy(err)
-      }
-    })
-
-    refresh()
-    emitter.on('update', refresh)
-
-    const destroy = stream.destroy.bind(stream)
-    stream.destroy = (err) => {
-      emitter.off('update', refresh)
-      return destroy(err)
-    }
-
-    return stream
-  }
-
-  /** @private Single-doc lookup by key (used internally by put/del) */
-  async _getOne(query) {
-    if (isLocal(this.scope)) {
-      return this.owner.local.get(this.path, query)
-    }
-    const snapshot = this.db.snapshot()
-    try {
-      return await snapshot.get(this.path, query)
-    } finally {
-      await snapshot.close()
-    }
-  }
-
-  /** @private Route write to local/identity/room */
-  async _write(op, data, isDel = false) {
-    await writeOp(this.owner, this.scope, this.path, this.ns, op, data, isDel)
-    return isDel ? true : data
-  }
-}
-
-// ==================== Private Helpers ====================
-
-function filter(all, query) {
-  const entries = Object.entries(query)
-  if (entries.length === 0) return all
-  return all.filter((doc) => entries.every(([k, v]) => doc[k] === v))
-}
-
-async function findDocs(db, path, indexes, name, query, opts) {
-  const snapshot = db.snapshot()
-
-  try {
-    const rangeKey = query.gte || query.gt || query.lte || query.lt
-    if (rangeKey) {
-      const index = matchIndex(path, indexes, rangeKey)
-      if (!index) throw new Error(`No index found for range query on ${name}`)
-      return snapshot.find(index, { ...query, ...opts }).toArray()
-    }
-
-    const index = matchIndex(path, indexes, query)
-    if (index) {
-      return snapshot.find(index, { gte: query, lte: query, ...opts }).toArray()
-    }
-
-    const all = await snapshot.find(path, opts).toArray()
-    return filter(all, query)
-  } finally {
-    await snapshot.close()
-  }
-}
-
-function matchIndex(path, indexes, query) {
-  if (!indexes) return null
-
-  const firstField = Object.keys(query)[0]
-  if (!firstField) return null
-
-  for (const [name, fields] of Object.entries(indexes)) {
-    if (fields[0] === firstField) return `${path}-${name}`
-  }
-  return null
-}

package/src/lib/crypto.js

@@ -1,6 +0,0 @@
-import crypto from 'hypercore-crypto'
-import z32 from 'z32'
-
-export function randomId() {
-  return z32.encode(crypto.randomBytes(16))
-}

package/src/lib/index.js

@@ -1,6 +0,0 @@
-export * from './base.js'
-export * from './room.js'
-export * from './batch.js'
-export * from './collection.js'
-export * from './schema.js'
-export * from './constants.js'

package/src/lib/room.js

@@ -1,145 +0,0 @@
-import ReadyResource from 'ready-resource'
-import safetyCatch from 'safety-catch'
-import HypercoreId from 'hypercore-id-encoding'
-
-import { Collection } from './collection.js'
-import { Batch } from './batch.js'
-
-/**
- * Room - Constructable ReadyResource for shared collections
- *
- * @example
- * const room = new Room(db)               // create new
- * const room = new Room(db, roomId)       // open existing
- * const room = new Room(db, invite)       // join via invite
- * await room.ready()
- *
- * const tasks = room.collection('tasks')
- * await tasks.insert({ text: 'Hello', done: false })
- *
- * @extends ReadyResource
- */
-export class Room extends ReadyResource {
-  /**
-   * @param {Cero} db - Cero instance
-   * @param {string} [arg] - Room ID or invite string (omit to create new)
-   * @param {object} [opts] - Options
-   * @param {AbortSignal} [opts.signal] - AbortSignal for cancellation
-   */
-  constructor(db, arg, opts = {}) {
-    super()
-
-    this.db = db
-    this.schema = db.schema
-
-    this._arg = arg
-    this._opts = opts
-
-    /** @type {import('cero').Room|null} - The underlying cero room */
-    this.room = null
-
-    this.ready().catch(safetyCatch)
-  }
-
-  /** Room ID (z32) */
-  get id() {
-    return this.room?.id
-  }
-
-  /** Room public key */
-  get publicKey() {
-    return this.room?.key
-  }
-
-  async _open() {
-    if (!this.db.opened) await this.db.ready()
-
-    const type = detectType(this._arg)
-
-    if (type === 'create') {
-      this.room = await this.db.rooms.create(this._opts)
-    } else if (type === 'invite') {
-      this.room = await this.db.rooms.pair(this._arg, this._opts)
-    } else {
-      this.room = await this.db.rooms.open(this._arg)
-    }
-
-    this.room.on('update', () => this.emit('update'))
-  }
-
-  async _close() {
-    if (!this.room) return
-    this.db.rooms.release(this.room)
-    this.room = null
-  }
-
-  /**
-   * Get a collection handle for shared data
-   * @param {string} name - Collection name
-   * @returns {Collection}
-   */
-  collection(name) {
-    this.schema.require(name, 'room')
-    return new Collection(this, name)
-  }
-
-  /**
-   * Create a batch for multiple operations
-   * @returns {Batch}
-   */
-  batch() {
-    return new Batch(this)
-  }
-
-  /** Shorthand — create invite and return the string */
-  async invite(opts = {}) {
-    if (!this.opened) await this.ready()
-    const { invite } = await this.room.invites.create(opts)
-    return invite
-  }
-
-  /**
-   * Dispatch an operation to the room
-   * @param {string} op - Operation path
-   * @param {object} data - Operation data
-   */
-  async dispatch(op, data) {
-    if (!this.opened) await this.ready()
-    return this.room.dispatch(op, data)
-  }
-
-  /**
-   * Async factory — creates room + awaits ready
-   * @param {Cero} db - Cero instance
-   * @param {string} [arg] - Room ID, invite, or null to create
-   * @param {object} [opts] - Options
-   * @returns {Promise<Room>}
-   */
-  static async from(db, arg, opts) {
-    const room = new this(db, arg, opts)
-    await room.ready()
-    return room
-  }
-}
-
-// ==================== Private Helpers ====================
-
-/**
- * Detect input type: nothing (create), id, or invite
- * @private
- */
-function detectType(input) {
-  if (!input) return 'create'
-
-  // z32 is ~52 chars, hex is 64 chars
-  if (input.length <= 64) {
-    try {
-      HypercoreId.decode(input)
-      return 'id'
-    } catch {
-      // Not a valid ID, assume invite
-    }
-  }
-
-  return 'invite'
-}