cloudbase-sdkv1 1.0.0

package/README.md

@@ -0,0 +1,97 @@
+# Cloudbase
+
+Cloudbase is a lightweight, server-side SDK to switch between cloud providers with a unified API.
+
+## Installation
+
+```bash
+npm install cloudbase
+```
+
+## Configuration
+
+Create `cloudbase.config.js` in your project root:
+
+```js
+module.exports = {
+  provider: "supabase",
+  url: "https://your-project.supabase.co",
+  key: "your-service-key"
+}
+```
+
+For Firebase (server-side):
+
+```js
+module.exports = {
+  provider: "firebase",
+  serviceAccount: require("./serviceAccount.json"),
+  storageBucket: "your-project-id.appspot.com"
+}
+```
+
+## Usage
+
+```js
+const { createClient } = require("cloudbase")
+
+const db = createClient()
+
+const User = db.model("users")
+
+await User.create({ name: "Aman", age: 21 })
+
+const adults = await User.find({ age: { gt: 18 } })
+
+const one = await User.findOne({ age: { gt: 18 } })
+```
+
+### Pagination
+
+```js
+await User.find({}, { limit: 10, offset: 0 })
+```
+
+### Sorting
+
+```js
+await User.find({}, { orderBy: "age", order: "desc" })
+```
+
+## Auth
+
+```js
+const auth = db.auth()
+
+await auth.signup("user@example.com", "password123")
+await auth.signin("user@example.com")
+await auth.logout()
+```
+
+### Firebase server-side helpers
+
+```js
+const auth = db.auth()
+const link = await auth.generateSignInWithEmailLink("user@example.com", actionCodeSettings)
+const reset = await auth.generatePasswordResetLink("user@example.com", actionCodeSettings)
+```
+
+## Storage
+
+```js
+const storage = db.storage()
+await storage.upload("avatars/user-1.png", buffer)
+const url = await storage.downloadUrl("avatars/user-1.png")
+```
+
+## Unified Errors
+
+All provider errors are wrapped as:
+
+```js
+{
+  name: "CloudbaseError",
+  type: "AUTH_ERROR" | "DB_ERROR" | "STORAGE_ERROR" | "CONFIG_ERROR",
+  message: "..."
+}
+```

package/auth/authLoader.js

@@ -0,0 +1,18 @@
+const FirebaseAuth = require("./firebaseAuth")
+const SupabaseAuth = require("./supbaseAuth")
+
+const authProviders = {
+  firebase: FirebaseAuth,
+  supabase: SupabaseAuth
+}
+
+function loadAuth(provider, config){
+  const AuthProvider = authProviders[provider]
+  if (!AuthProvider) {
+    throw new Error("Unsupported auth provider")
+  }
+
+  return new AuthProvider(config)
+}
+
+module.exports = loadAuth

package/auth/firebaseAuth.js

@@ -0,0 +1,74 @@
+const getFirebaseApp = require("../providers/firebase/firebaseApp")
+
+class FirebaseAuth {
+
+  constructor(config){
+    getFirebaseApp(config)
+    const admin = require("firebase-admin")
+    this.auth = admin.auth()
+  }
+
+  async signup(email, password){
+    const user = await this.auth.createUser({
+      email,
+      password
+    })
+
+    return { user, session: null }
+  }
+
+  async signin(email){
+    const user = await this.auth.getUserByEmail(email)
+    return { user, session: null }
+  }
+
+  async createCustomToken(uid, claims) {
+    const token = await this.auth.createCustomToken(uid, claims)
+    return { token }
+  }
+
+  async verifyIdToken(idToken) {
+    const decoded = await this.auth.verifyIdToken(idToken)
+    return { decoded }
+  }
+
+  async setCustomClaims(uid, claims) {
+    await this.auth.setCustomUserClaims(uid, claims)
+    return { success: true }
+  }
+
+  async generatePasswordResetLink(email, actionCodeSettings){
+    const link = await this.auth.generatePasswordResetLink(email, actionCodeSettings)
+    return { link }
+  }
+
+  async generateEmailVerificationLink(email, actionCodeSettings){
+    const link = await this.auth.generateEmailVerificationLink(email, actionCodeSettings)
+    return { link }
+  }
+
+  async generateSignInWithEmailLink(email, actionCodeSettings){
+    const link = await this.auth.generateSignInWithEmailLink(email, actionCodeSettings)
+    return { link }
+  }
+
+  async revokeRefreshTokens(uid){
+    await this.auth.revokeRefreshTokens(uid)
+    return { success: true }
+  }
+
+  async listUsers(maxResults = 1000, pageToken) {
+    return this.auth.listUsers(maxResults, pageToken)
+  }
+
+  async logout(uid){
+    if (!uid) {
+      return { success: true }
+    }
+    await this.auth.revokeRefreshTokens(uid)
+    return { success:true }
+  }
+
+}
+
+module.exports = FirebaseAuth

package/auth/supbaseAuth.js

@@ -0,0 +1,91 @@
+const { createClient } = require("@supabase/supabase-js")
+
+class SupabaseAuth {
+
+  constructor(config){
+    this.client = createClient(config.url, config.key)
+  }
+
+  async signup(email, password){
+    return this.signupWithEmailPassword(email, password)
+  }
+
+  async signin(email, password){
+    return this.signinWithEmailPassword(email, password)
+  }
+
+  async signupWithEmailPassword(email, password){
+
+    const { data, error } = await this.client.auth.signUp({
+      email,
+      password
+    })
+
+    if(error) throw error
+
+    return {
+      user: data.user,
+      session: data.session
+    }
+  }
+
+  async signinWithEmailPassword(email, password){
+
+    const { data, error } =
+      await this.client.auth.signInWithPassword({
+        email,
+        password
+      })
+
+    if(error) throw error
+
+    return {
+      user: data.user,
+      session: data.session
+    }
+  }
+
+  async logout(){
+
+    const { error } = await this.client.auth.signOut()
+
+    if(error) throw error
+
+    return { success:true }
+  }
+
+  async sendEmailLink(email, options = {}){
+    const { data, error } = await this.client.auth.signInWithOtp({
+      email,
+      options
+    })
+
+    if(error) throw error
+
+    return { data }
+  }
+
+  async signinWithOAuth(provider, options = {}){
+    const { data, error } = await this.client.auth.signInWithOAuth({
+      provider,
+      options
+    })
+
+    if(error) throw error
+
+    return { data }
+  }
+
+  async handleOAuthCallback(url){
+    const { data, error } = await this.client.auth.exchangeCodeForSession(url)
+    if(error) throw error
+    return { data }
+  }
+
+  onAuthStateChange(handler){
+    return this.client.auth.onAuthStateChange(handler)
+  }
+
+}
+
+module.exports = SupabaseAuth

package/config/configLoader.js

@@ -0,0 +1,31 @@
+const fs = require("fs")
+const path = require("path")
+const { wrapError } = require("../packages/core/errors")
+
+function loadConfig(providedConfig) {
+  if (providedConfig && typeof providedConfig === "object") {
+    return providedConfig
+  }
+
+  const configPath = path.join(process.cwd(), "cloudbase.config.js")
+
+  if (!fs.existsSync(configPath)) {
+    throw wrapError(
+      new Error("Missing cloudbase.config.js and no config provided to createClient"),
+      "CONFIG_ERROR",
+      { path: configPath }
+    )
+  }
+
+  try {
+    const config = require(configPath)
+    if (!config || typeof config !== "object") {
+      throw new Error("cloudbase.config.js must export an object")
+    }
+    return config
+  } catch (err) {
+    throw wrapError(err, "CONFIG_ERROR", { path: configPath })
+  }
+}
+
+module.exports = loadConfig

package/examples/README.md

@@ -0,0 +1,15 @@
+# Examples
+
+These examples are server-side usage patterns. Replace config values with your own.
+
+## Supabase
+
+```bash
+node examples/supabase.js
+```
+
+## Firebase
+
+```bash
+node examples/firebase.js
+```

package/examples/firebase.js

@@ -0,0 +1,33 @@
+const { createClient } = require("..")
+
+const db = createClient({
+  provider: "firebase",
+  serviceAccount: require("../serviceAccount.json"),
+  storageBucket: "your-project-id.appspot.com"
+})
+
+async function run() {
+  const User = db.model("users")
+
+  await User.create({ name: "Aman", age: 21 })
+
+  const adults = await User.find({ age: { gt: 18 } }, { limit: 10, offset: 0 })
+  console.log("Adults:", adults)
+
+  const one = await User.findOne({ age: { gt: 18 } })
+  console.log("One:", one)
+
+  const auth = db.auth()
+  await auth.generateSignInWithEmailLink("user@example.com", {
+    url: "https://example.com/finishSignIn",
+    handleCodeInApp: true
+  })
+
+  const storage = db.storage()
+  await storage.list("avatars")
+}
+
+run().catch(err => {
+  console.error(err)
+  process.exit(1)
+})

package/examples/supabase.js

@@ -0,0 +1,31 @@
+const { createClient } = require("..")
+
+const db = createClient({
+  provider: "supabase",
+  url: "project_url",
+  key: "your-service-key",
+  bucket: "public"
+})
+
+async function run() {
+  const User = db.model("users")
+
+  await User.create({ name: "Aman", age: 21 })
+
+  const adults = await User.find({ age: { gt: 18 } }, { limit: 10, offset: 0 })
+  console.log("Adults:", adults)
+
+  const one = await User.findOne({ age: { gt: 18 } })
+  console.log("One:", one)
+
+  const auth = db.auth()
+  await auth.signup("user@example.com", "password123")
+
+  const storage = db.storage().from("public")
+  await storage.list("", { limit: 10 })
+}
+
+run().catch(err => {
+  console.error(err)
+  process.exit(1)
+})

package/index.js

@@ -0,0 +1,5 @@
+const createClient = require("./packages/core/client")
+
+module.exports = {
+  createClient
+}

package/orm/model.js

@@ -0,0 +1,31 @@
+class Model {
+
+    constructor(name, client) {
+        this.name = name
+        this.client = client
+    }
+
+    async create(data) {
+        return this.client.insert(this.name, data)
+    }
+
+    async find(query = {}, options = {}) {
+        return this.client.find(this.name, query, options)
+    }
+
+    async findOne(query = {}, options = {}) {
+        const results = await this.find(query, { ...options, limit: 1 })
+        return results && results.length ? results[0] : null
+    }
+
+    async update(query, data) {
+        return this.client.update(this.name, query, data)
+    }
+
+    async delete(query) {
+        return this.client.delete(this.name, query)
+    }
+
+}
+
+module.exports = Model

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "cloudbase-sdkv1",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@supabase/supabase-js": "^2.99.1",
+    "firebase-admin": "^13.7.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}

package/packages/adapters/firebase/index.js

@@ -0,0 +1,78 @@
+const getFirebaseApp = require("../../../providers/firebase/firebaseApp")
+const parseQuery = require("../../../parser/queryParser")
+
+class FirebaseAdapter {
+
+  constructor(config) {
+    getFirebaseApp(config)
+    const admin = require("firebase-admin")
+    this.db = admin.firestore()
+  }
+
+  async insert(collectionName, data) {
+    return this.db.collection(collectionName).add(data)
+  }
+
+  async find(collectionName, queryObject = {}, options = {}) {
+    const conditions = parseQuery(queryObject)
+    let request = this.db.collection(collectionName)
+
+    for (const cond of conditions) {
+      let op = cond.operator
+      if (cond.operator === "eq") op = "=="
+      if (cond.operator === "gt") op = ">"
+      if (cond.operator === "lt") op = "<"
+      if (cond.operator === "gte") op = ">="
+      if (cond.operator === "lte") op = "<="
+      request = request.where(cond.field, op, cond.value)
+    }
+
+    if (options.orderBy) {
+      const direction = options.order === "desc" ? "desc" : "asc"
+      request = request.orderBy(options.orderBy, direction)
+    }
+
+    if (Number.isInteger(options.limit)) {
+      request = request.limit(options.limit)
+    }
+
+    if (Number.isInteger(options.offset)) {
+      request = request.offset(options.offset)
+    }
+
+    const snapshot = await request.get()
+    return snapshot.docs.map(docSnap => ({ id: docSnap.id, ...docSnap.data() }))
+  }
+
+  async update(collectionName, queryObject, data) {
+    const { ids, docs } = await this._resolveDocs(collectionName, queryObject)
+    const updates = docs.map((docRef, index) => docRef.update(data).then(() => ids[index]))
+    return Promise.all(updates)
+  }
+
+  async delete(collectionName, queryObject) {
+    const { ids, docs } = await this._resolveDocs(collectionName, queryObject)
+    const deletions = docs.map((docRef, index) => docRef.delete().then(() => ids[index]))
+    return Promise.all(deletions)
+  }
+
+  async _resolveDocs(collectionName, queryObject = {}) {
+    if (queryObject && (queryObject.id || queryObject._id)) {
+      const id = queryObject.id || queryObject._id
+      return {
+        ids: [id],
+        docs: [this.db.collection(collectionName).doc(id)]
+      }
+    }
+
+    const results = await this.find(collectionName, queryObject)
+    const ids = results.map(item => item.id).filter(Boolean)
+    return {
+      ids,
+      docs: ids.map(id => this.db.collection(collectionName).doc(id))
+    }
+  }
+
+}
+
+module.exports = FirebaseAdapter

package/packages/adapters/supabase/index.js

@@ -0,0 +1,121 @@
+const { createClient } = require("@supabase/supabase-js")
+const parseQuery = require("../../../parser/queryParser")
+
+class SupabaseAdapter {
+
+  constructor(config) {
+    this.client = createClient(config.url, config.key)
+  }
+
+  async insert(table, data) {
+    return this.client.from(table).insert(data)
+  }
+
+
+  async find(table, query = {}, options = {}) {
+
+    const conditions = parseQuery(query)
+
+    let request = this.client.from(table).select("*")
+
+    for (const cond of conditions) {
+
+      if (cond.operator === "eq") {
+        request = request.eq(cond.field, cond.value)
+      }
+
+      if (cond.operator === "gt") {
+        request = request.gt(cond.field, cond.value)
+      }
+
+      if (cond.operator === "gte") {
+        request = request.gte(cond.field, cond.value)
+      }
+
+      if (cond.operator === "lt") {
+        request = request.lt(cond.field, cond.value)
+      }
+
+      if (cond.operator === "lte") {
+        request = request.lte(cond.field, cond.value)
+      }
+
+    }
+
+    if (options.orderBy) {
+      const ascending = options.order !== "desc"
+      request = request.order(options.orderBy, { ascending })
+    }
+
+    if (Number.isInteger(options.offset) && Number.isInteger(options.limit)) {
+      request = request.range(options.offset, options.offset + options.limit - 1)
+    } else if (Number.isInteger(options.limit)) {
+      request = request.limit(options.limit)
+    }
+
+    const { data, error } = await request
+
+    if (error) throw error
+
+    return data
+  }
+
+  async update(table, query = {}, data) {
+    const conditions = parseQuery(query)
+
+    let request = this.client.from(table).update(data)
+
+    for (const cond of conditions) {
+      if (cond.operator === "eq") {
+        request = request.eq(cond.field, cond.value)
+      }
+      if (cond.operator === "gt") {
+        request = request.gt(cond.field, cond.value)
+      }
+      if (cond.operator === "gte") {
+        request = request.gte(cond.field, cond.value)
+      }
+      if (cond.operator === "lt") {
+        request = request.lt(cond.field, cond.value)
+      }
+      if (cond.operator === "lte") {
+        request = request.lte(cond.field, cond.value)
+      }
+    }
+
+    const { data: updated, error } = await request.select()
+    if (error) throw error
+    return updated
+  }
+
+  async delete(table, query = {}) {
+    const conditions = parseQuery(query)
+
+    let request = this.client.from(table).delete()
+
+    for (const cond of conditions) {
+      if (cond.operator === "eq") {
+        request = request.eq(cond.field, cond.value)
+      }
+      if (cond.operator === "gt") {
+        request = request.gt(cond.field, cond.value)
+      }
+      if (cond.operator === "gte") {
+        request = request.gte(cond.field, cond.value)
+      }
+      if (cond.operator === "lt") {
+        request = request.lt(cond.field, cond.value)
+      }
+      if (cond.operator === "lte") {
+        request = request.lte(cond.field, cond.value)
+      }
+    }
+
+    const { data: deleted, error } = await request.select()
+    if (error) throw error
+    return deleted
+  }
+
+}
+
+module.exports = SupabaseAdapter

package/packages/core/adapterLoader.js

@@ -0,0 +1,18 @@
+const FirebaseAdapter = require("../adapters/firebase")
+const SupabaseAdapter = require("../adapters/supabase")
+
+const adapterProviders = {
+  firebase: FirebaseAdapter,
+  supabase: SupabaseAdapter
+}
+
+function loadAdapter(provider, config) {
+  const Adapter = adapterProviders[provider]
+  if (!Adapter) {
+    throw new Error("Unsupported provider")
+  }
+
+  return new Adapter(config)
+}
+
+module.exports = loadAdapter

package/packages/core/client.js

@@ -0,0 +1,81 @@
+const loadAdapter = require("./adapterLoader")
+const Model = require("../../orm/model")
+const loadAuth = require("../../auth/authLoader")
+const loadStorage = require("../../storage/storageLoader")
+const loadConfig = require("../../config/configLoader")
+const { wrapError } = require("./errors")
+
+function wrapProvider(provider, type) {
+  return new Proxy(provider, {
+    get(target, prop) {
+      const value = target[prop]
+      if (typeof value !== "function") {
+        return value
+      }
+      return (...args) => {
+        try {
+          const result = value.apply(target, args)
+          if (result && typeof result.then === "function") {
+            return result.catch(err => {
+              throw wrapError(err, type)
+            })
+          }
+          return result
+        } catch (err) {
+          throw wrapError(err, type)
+        }
+      }
+    }
+  })
+}
+
+class CloudClient {
+
+  constructor(config){
+    this.config = config
+    this.adapter = wrapProvider(loadAdapter(config.provider, config), "DB_ERROR")
+    this.authProvider = wrapProvider(loadAuth(config.provider, config), "AUTH_ERROR")
+    this.storageProvider = wrapProvider(loadStorage(config.provider, config), "STORAGE_ERROR")
+    this.capabilities = {
+      auth: true,
+      database: true,
+      storage: true
+    }
+  }
+
+  model(name){
+    return new Model(name, this)
+  }
+
+  auth(){
+    return this.authProvider
+  }
+
+  storage(){
+    return this.storageProvider
+  }
+
+  async insert(collection, data) {
+    return this.adapter.insert(collection, data)
+  }
+
+  async find(collection, query, options) {
+    return this.adapter.find(collection, query, options)
+  }
+
+  async update(collection, query, data) {
+    return this.adapter.update(collection, query, data)
+  }
+
+  async delete(collection, query) {
+    return this.adapter.delete(collection, query)
+  }
+
+}
+
+function createClient(config) {
+  const resolvedConfig = loadConfig(config)
+  return new CloudClient(resolvedConfig)
+}
+
+module.exports = createClient

package/packages/core/errors.js

@@ -0,0 +1,23 @@
+class CloudbaseError extends Error {
+  constructor(type, message, details = {}, cause = null) {
+    super(message)
+    this.name = "CloudbaseError"
+    this.type = type
+    this.details = details
+    this.cause = cause
+  }
+}
+
+function wrapError(err, type, details = {}) {
+  if (err instanceof CloudbaseError) {
+    return err
+  }
+
+  const message = err && err.message ? err.message : "Unknown error"
+  return new CloudbaseError(type, message, details, err)
+}
+
+module.exports = {
+  CloudbaseError,
+  wrapError
+}

package/parser/queryParser.js

@@ -0,0 +1,58 @@
+function parseQuery(query) {
+
+  const conditions = []
+
+  for (const field in query) {
+
+    const value = query[field]
+
+    if (typeof value === "object") {
+
+      if (value.gt) {
+        conditions.push({
+          field,
+          operator: "gt",
+          value: value.gt
+        })
+      }
+
+      if (value.gte) {
+        conditions.push({
+          field,
+          operator: "gte",
+          value: value.gte
+        })
+      }
+
+      if (value.lt) {
+        conditions.push({
+          field,
+          operator: "lt",
+          value: value.lt
+        })
+      }
+
+      if (value.lte) {
+        conditions.push({
+          field,
+          operator: "lte",
+          value: value.lte
+        })
+      }
+
+    } else {
+
+      conditions.push({
+        field,
+        operator: "eq",
+        value
+      })
+
+    }
+
+  }
+
+  return conditions
+}
+
+module.exports = parseQuery

package/providers/firebase/firebaseApp.js

@@ -0,0 +1,18 @@
+const admin = require("firebase-admin")
+
+function getFirebaseApp(config) {
+  if (!config.serviceAccount) {
+    throw new Error("Missing firebase serviceAccount in config")
+  }
+
+  if (admin.apps.length) {
+    return admin.app()
+  }
+
+  return admin.initializeApp({
+    credential: admin.credential.cert(config.serviceAccount),
+    storageBucket: config.storageBucket
+  })
+}
+
+module.exports = getFirebaseApp

package/storage/firebaseStorage.js

@@ -0,0 +1,35 @@
+const getFirebaseApp = require("../providers/firebase/firebaseApp")
+
+class FirebaseStorage {
+  constructor(config) {
+    getFirebaseApp(config)
+    const admin = require("firebase-admin")
+    this.bucket = admin.storage().bucket()
+  }
+
+  async upload(path, file, metadata) {
+    const fileRef = this.bucket.file(path)
+    await fileRef.save(file, { metadata })
+    return { path }
+  }
+
+  async downloadUrl(path) {
+    const [url] = await this.bucket.file(path).getSignedUrl({
+      action: "read",
+      expires: Date.now() + 60 * 60 * 1000
+    })
+    return { url }
+  }
+
+  async list(path) {
+    const [files] = await this.bucket.getFiles({ prefix: path })
+    return files.map(file => ({ name: file.name, path: file.name }))
+  }
+
+  async remove(path) {
+    await this.bucket.file(path).delete()
+    return { success: true }
+  }
+}
+
+module.exports = FirebaseStorage

package/storage/storageLoader.js

@@ -0,0 +1,18 @@
+const FirebaseStorage = require("./firebaseStorage")
+const SupabaseStorage = require("./supabaseStorage")
+
+const storageProviders = {
+  firebase: FirebaseStorage,
+  supabase: SupabaseStorage
+}
+
+function loadStorage(provider, config) {
+  const StorageProvider = storageProviders[provider]
+  if (!StorageProvider) {
+    throw new Error("Unsupported storage provider")
+  }
+
+  return new StorageProvider(config)
+}
+
+module.exports = loadStorage

package/storage/supabaseStorage.js

@@ -0,0 +1,64 @@
+const { createClient } = require("@supabase/supabase-js")
+
+class SupabaseStorage {
+  constructor(config) {
+    this.client = createClient(config.url, config.key)
+    this.bucket = config.bucket || "public"
+  }
+
+  from(bucket) {
+    this.bucket = bucket
+    return this
+  }
+
+  async upload(path, file, options = {}) {
+    const { data, error } = await this.client.storage
+      .from(this.bucket)
+      .upload(path, file, options)
+
+    if (error) throw error
+    return data
+  }
+
+  async download(path) {
+    const { data, error } = await this.client.storage
+      .from(this.bucket)
+      .download(path)
+
+    if (error) throw error
+    return data
+  }
+
+  async list(path, options = {}) {
+    const { data, error } = await this.client.storage
+      .from(this.bucket)
+      .list(path, options)
+
+    if (error) throw error
+    return data
+  }
+
+  async remove(paths = []) {
+    const { data, error } = await this.client.storage
+      .from(this.bucket)
+      .remove(paths)
+
+    if (error) throw error
+    return data
+  }
+
+  getPublicUrl(path) {
+    return this.client.storage.from(this.bucket).getPublicUrl(path)
+  }
+
+  async getSignedUrl(path, expiresIn = 60) {
+    const { data, error } = await this.client.storage
+      .from(this.bucket)
+      .createSignedUrl(path, expiresIn)
+
+    if (error) throw error
+    return data
+  }
+}
+
+module.exports = SupabaseStorage