@bullet./paraql 0.1.0

package/binding.js

@@ -0,0 +1,3 @@
+require.addon = require("require-addon")
+
+module.exports = require.addon(".", __filename)

package/index.js

@@ -0,0 +1,148 @@
+const { Buffer } = require("buffer")
+const ReadyResource = require("ready-resource")
+
+const binding = require("./binding")
+const errors = require("./lib/errors")
+const ParaQLStatement = require("./lib/statement")
+const ParaVFS = require("./lib/vfs")
+
+module.exports = exports = class ParaQL extends ReadyResource {
+  constructor(store, key = null, options = {}) {
+    if (isObject(key)) {
+      options = key
+      key = null
+    }
+
+    const { cacheSize = 1024, ...opts } = options
+
+    super()
+
+    this._handle = null
+    this._vfs = new ParaVFS(this, store, key, opts)
+    this._cacheSize = cacheSize
+    this._cache = new Map()
+  }
+
+  get name() {
+    return this._vfs.name
+  }
+
+  get key() {
+    return this._vfs.key
+  }
+
+  get local() {
+    return this._vfs.local
+  }
+
+  get discoveryKey() {
+    return this._vfs.discoveryKey
+  }
+
+  get encryptionKey() {
+    return this._vfs.encryptionKey
+  }
+
+  get writable() {
+    return this._vfs.writable
+  }
+
+  get encrypted() {
+    return this._vfs.encrypted
+  }
+
+  async _open() {
+    await this._vfs.ready()
+
+    try {
+      this._handle = await binding.open("paraql.db")
+    } catch (err) {
+      throw errors.from(err)
+    }
+  }
+
+  async _close() {
+    if (this.opened) {
+      try {
+        for (const stmt of this._cache.values()) {
+          await stmt.finalize()
+        }
+
+        this._cache.clear()
+        await binding.close(this._handle)
+      } catch (err) {
+        throw errors.from(err)
+      }
+    }
+
+    await this._vfs.close()
+  }
+
+  async addWriter(key) {
+    await this._vfs.addWriter(key)
+  }
+
+  async removeWriter(key) {
+    await this._vfs.removeWriter(key)
+  }
+
+  replicate(isInitiator) {
+    return this._vfs.replicate(isInitiator)
+  }
+
+  async compact() {
+    return this._vfs.compact()
+  }
+
+  async info() {
+    return this._vfs.info()
+  }
+
+  async _exec(sql) {
+    try {
+      await binding.exec(this._handle, sql)
+    } catch (err) {
+      throw errors.from(err)
+    }
+  }
+
+  async exec(sql) {
+    if (!this.opened) await this.ready()
+
+    if (this.closed) throw errors.ALREADY_CLOSED()
+
+    await this._vfs.exec(sql)
+  }
+
+  async prepare(sql) {
+    if (!this.opened) await this.ready()
+
+    if (this.closed) throw errors.ALREADY_CLOSED()
+
+    let stmt = this._cache.get(sql)
+
+    if (stmt) {
+      this._cache.delete(sql)
+      this._cache.set(sql, stmt)
+      return stmt
+    }
+
+    stmt = new ParaQLStatement(this, sql)
+
+    await stmt.ready()
+
+    this._cache.set(sql, stmt)
+
+    if (this._cache.size > this._cacheSize) {
+      const oldest = this._cache.values().next().value
+
+      await oldest.finalize()
+    }
+
+    return stmt
+  }
+}
+
+function isObject(o) {
+  return typeof o === "object" && o && !Buffer.isBuffer(o)
+}

package/lib/codecs.js

@@ -0,0 +1,138 @@
+const c = require("compact-encoding")
+const IndexEncoder = require("index-encoder")
+const zlib = require("zlib")
+
+const { OPERATION, PAGE_SIZE } = require("./constants")
+
+const op = {
+  preencode(state, operation) {
+    c.uint8.preencode(state, operation.type)
+
+    switch (operation.type) {
+      case OPERATION.WRITER_ADD:
+      case OPERATION.WRITER_DEL: {
+        c.fixed32.preencode(state, operation.key)
+        break
+      }
+      case OPERATION.EXEC: {
+        c.string.preencode(state, operation.sql)
+        break
+      }
+      case OPERATION.RUN: {
+        c.string.preencode(state, operation.sql)
+        c.any.preencode(state, operation.named)
+        c.any.preencode(state, operation.positional)
+        break
+      }
+      case OPERATION.STMT: {
+        c.string.preencode(state, operation.sql)
+      }
+      case OPERATION.BATCH: {
+        c.any.preencode(state, operation.named)
+        c.any.preencode(state, operation.positional)
+      }
+      case OPERATION.FLUSH: {
+        break
+      }
+    }
+  },
+  encode(state, operation) {
+    c.uint8.encode(state, operation.type)
+
+    switch (operation.type) {
+      case OPERATION.WRITER_ADD:
+      case OPERATION.WRITER_DEL: {
+        c.fixed32.encode(state, operation.key)
+        break
+      }
+      case OPERATION.EXEC: {
+        c.string.encode(state, operation.sql)
+        break
+      }
+      case OPERATION.RUN: {
+        c.string.encode(state, operation.sql)
+        c.any.encode(state, operation.named)
+        c.any.encode(state, operation.positional)
+        break
+      }
+      case OPERATION.STMT: {
+        c.string.encode(state, operation.sql)
+      }
+      case OPERATION.BATCH: {
+        c.any.encode(state, operation.named)
+        c.any.encode(state, operation.positional)
+      }
+      case OPERATION.FLUSH: {
+        break
+      }
+    }
+  },
+  decode(state) {
+    const type = c.uint8.decode(state)
+
+    const operation = { type }
+
+    switch (type) {
+      case OPERATION.WRITER_ADD:
+      case OPERATION.WRITER_DEL: {
+        operation.key = c.fixed32.decode(state)
+        break
+      }
+      case OPERATION.EXEC: {
+        operation.sql = c.string.decode(state)
+        break
+      }
+      case OPERATION.RUN: {
+        operation.sql = c.string.decode(state)
+        operation.named = c.any.decode(state)
+        operation.positional = c.any.decode(state)
+        break
+      }
+      case OPERATION.STMT: {
+        operation.sql = c.string.decode(state)
+      }
+      case OPERATION.BATCH: {
+        operation.named = c.any.decode(state)
+        operation.positional = c.any.decode(state)
+      }
+      case OPERATION.FLUSH: {
+        break
+      }
+    }
+
+    return operation
+  },
+}
+
+module.exports.PageKey = new IndexEncoder([IndexEncoder.STRING, IndexEncoder.UINT])
+
+module.exports.Operation = {
+  encode(operation) {
+    return c.encode(op, operation)
+  },
+  decode(operation) {
+    return c.decode(op, operation)
+  },
+}
+
+module.exports.deflate = async function (buffer, options) {
+  return new Promise((resolve, reject) =>
+    zlib.deflate(buffer, { chunkSize: PAGE_SIZE, ...options }, (err, result) => {
+      if (err) {
+        return reject(result)
+      }
+      resolve(result)
+    }),
+  )
+}
+
+module.exports.inflate = async function (buffer, options) {
+  return new Promise((resolve, reject) =>
+    zlib.inflate(buffer, { chunkSize: PAGE_SIZE, ...options }, (err, result) => {
+      if (err) {
+        return reject(result)
+      }
+      resolve(result)
+    }),
+  )
+}

package/lib/constants.js

@@ -0,0 +1,10 @@
+module.exports.PAGE_SIZE = 4096
+module.exports.OPERATION = {
+  WRITER_ADD: 1,
+  WRITER_DEL: 2,
+  EXEC: 8,
+  RUN: 9,
+  STMT: 10,
+  BATCH: 11,
+  FLUSH: 12,
+}

package/lib/deferred.js

@@ -0,0 +1,8 @@
+module.exports = class Deferred {
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve
+      this.reject = reject
+    })
+  }
+}

package/lib/encryption.js

@@ -0,0 +1,39 @@
+const { Buffer } = require("buffer")
+const c = require("compact-encoding")
+const sodium = require("sodium-native")
+
+const errors = require("./errors")
+
+module.exports = class ParaQLEncryption {
+  constructor(key, encryptionKey) {
+    if (
+      !Buffer.isBuffer(encryptionKey)
+      || encryptionKey.byteLength !== sodium.crypto_stream_KEYBYTES
+    ) {
+      throw errors.INVALID_ARGUMENT("`encryptioKey` must be 32 byte buffer")
+    }
+
+    this._key = key
+    this._encryptionKey = encryptionKey
+  }
+
+  _nonce(name, index) {
+    const _name = Buffer.from(name)
+    const _index = c.encode(c.uint64, index)
+    const result = Buffer.alloc(sodium.crypto_stream_NONCEBYTES)
+
+    sodium.crypto_generichash(result, Buffer.concat([this._key, _name, _index]))
+
+    return result
+  }
+
+  encrypt(page, filename, index) {
+    sodium.crypto_stream_xor(page, page, this._nonce(filename, index), this._encryptionKey)
+    return page
+  }
+
+  decrypt(page, filename, index) {
+    sodium.crypto_stream_xor(page, page, this._nonce(filename, index), this._encryptionKey)
+    return page
+  }
+}

package/lib/errors.js

@@ -0,0 +1,35 @@
+module.exports = class ParaQLError extends Error {
+  constructor(message, fn = ParaQLError, code = fn.name) {
+    super(`${code}: ${message}`)
+
+    this.code = code
+
+    if (Error.captureStackTrace) Error.captureStackTrace(this, fn)
+  }
+
+  get name() {
+    return "ParaQLError"
+  }
+
+  static INTERNAL(message) {
+    return new ParaQLError(message, ParaQLError.INTERNAL)
+  }
+
+  static ALREADY_CLOSED(message = "Database has already been closed") {
+    return new ParaQLError(message, ParaQLError.ALREADY_CLOSED)
+  }
+
+  static INVALID_ARGUMENT(message) {
+    return new ParaQLError(message, ParaQLError.INVALID_ARGUMENT)
+  }
+
+  static from(err) {
+    if (err instanceof ParaQLError) return err
+
+    if (err instanceof TypeError) {
+      return ParaQLError.INVALID_ARGUMENT(err.message)
+    }
+
+    return new ParaQLError(err.message, ParaQLError.from, err.code || "ERROR")
+  }
+}

package/lib/statement.d.ts

@@ -0,0 +1,55 @@
+import ReadyResource from "ready-resource"
+import Buffer from "bare-buffer"
+
+interface ParaQLStatement extends ReadyResource {
+  readonly sourceSQL: string
+  readonly batching: boolean
+
+  batch(on: boolean): void
+
+  flush(): Promise<ParaQLStatement.FlushResult>
+
+  finalize(): Promise<void>
+
+  all<T extends ParaQLStatement.Row = ParaQLStatement.Row>(
+    ...params: ParaQLStatement.Parameters
+  ): Promise<T[]>
+
+  get<T extends ParaQLStatement.Row = ParaQLStatement.Row>(
+    ...params: ParaQLStatement.Parameters
+  ): Promise<T | undefined>
+
+  run(...params: ParaQLStatement.Parameters): Promise<ParaQLStatement.RunResult | undefined>
+
+  iterate<T extends ParaQLStatement.Row = ParaQLStatement.Row>(
+    ...params: ParaQLStatement.Parameters
+  ): AsyncIterableIterator<T>
+}
+
+declare class ParaQLStatement {}
+
+declare namespace ParaQLStatement {
+  export type Value = null | number | string | Buffer
+
+  export type BindValue =
+    null | undefined | number | bigint | string | ArrayBuffer | ArrayBufferView
+
+  export type Row = Record<string, Value>
+
+  export type NamedParameters = Record<string, BindValue>
+
+  export type Parameters = [NamedParameters, ...BindValue[]] | BindValue[]
+
+  export interface RunResult {
+    changes: number
+    lastInsertRowid: number
+  }
+
+  export interface FlushResult {
+    changes: number
+    lastInsertRowid: number
+    errors: number
+  }
+}
+
+export = ParaQLStatement

package/lib/statement.js

@@ -0,0 +1,168 @@
+const { Buffer } = require("buffer")
+const ReadyResource = require("ready-resource")
+
+const binding = require("../binding")
+const errors = require("./errors")
+
+module.exports = class ParaQLStatement extends ReadyResource {
+  constructor(db, sql) {
+    super()
+
+    this._db = db
+    this._sourceSQL = sql
+    this._handle = null
+    this._queue = null
+  }
+
+  async _open() {
+    try {
+      this._handle = await binding.prepare(this._db._handle, this._sourceSQL)
+    } catch (err) {
+      throw errors.from(err)
+    }
+  }
+
+  async _close() {
+    if (this.opened) {
+      try {
+        await binding.finalize(this._handle)
+        this._handle = null
+        this._queue = null
+        this._db._cache.delete(this._sourceSQL)
+      } catch (err) {
+        throw errors.from(err)
+      }
+    }
+  }
+
+  get sourceSQL() {
+    return this._sourceSQL
+  }
+
+  get batching() {
+    return !!this._queue
+  }
+
+  batch(on) {
+    if (on === false) {
+      this._queue = null
+    } else {
+      this._queue = this._queue ?? []
+    }
+  }
+
+  async finalize() {
+    await this.close()
+  }
+
+  async flush() {
+    const queue = this._queue
+    this._queue = []
+    return this._db._vfs.flush(this._sourceSQL, queue)
+  }
+
+  async _bind(named, positional) {
+    for (const key in named) {
+      if (Array.isArray(named[key])) named[key] = JSON.stringify(named[key])
+    }
+
+    for (let i = 0; i < positional.length; i++) {
+      if (Array.isArray(positional[i])) positional[i] = JSON.stringify(positional[i])
+    }
+
+    return binding.bind(this._handle, named, positional)
+  }
+
+  async all(...params) {
+    if (this.closed) throw errors.ALREADY_CLOSED()
+
+    const rows = []
+
+    for await (const row of this.iterate(...params)) {
+      rows.push(row)
+    }
+
+    return rows
+  }
+
+  async get(...params) {
+    if (this.closed) throw errors.ALREADY_CLOSED()
+
+    const [named, positional] = splitParameters(params)
+
+    try {
+      await this._bind(named, positional)
+      const row = await binding.step(this._handle)
+      return row === undefined ? undefined : wrapBlobRow(row)
+    } catch (err) {
+      throw errors.from(err)
+    } finally {
+      await binding.reset(this._handle)
+    }
+  }
+
+  async _run(named, positional) {
+    try {
+      await this._bind(named, positional)
+      return await binding.run(this._handle)
+    } catch (err) {
+      throw errors.from(err)
+    } finally {
+      await binding.reset(this._handle)
+    }
+  }
+
+  async run(...params) {
+    if (this.closed) throw errors.ALREADY_CLOSED()
+
+    const [named, positional] = splitParameters(params)
+
+    if (this._queue) {
+      this._queue.push({ named, positional })
+      return null
+    } else {
+      return this._db._vfs.run(this._sourceSQL, named, positional)
+    }
+  }
+
+  async *iterate(...params) {
+    if (this.closed) throw errors.ALREADY_CLOSED()
+
+    const [named, positional] = splitParameters(params)
+
+    try {
+      await this._bind(named, positional)
+
+      let row
+      while ((row = await binding.step(this._handle)) !== undefined) {
+        yield wrapBlobRow(row)
+      }
+    } catch (err) {
+      throw errors.from(err)
+    } finally {
+      await binding.reset(this._handle)
+    }
+  }
+}
+
+function wrapBlobRow(row) {
+  for (const key in row) {
+    if (row[key] instanceof ArrayBuffer) row[key] = Buffer.from(row[key])
+  }
+  return row
+}
+
+function splitParameters(params) {
+  if (params.length === 0) return [null, params]
+  if (!isNamedParameters(params[0])) return [null, params]
+  return [params[0], params.slice(1)]
+}
+
+function isNamedParameters(value) {
+  if (value === null) return false
+  if (typeof value !== "object") return false
+  if (Array.isArray(value)) return false
+  if (ArrayBuffer.isView(value)) return false
+  if (value instanceof ArrayBuffer) return false
+  return true
+}