What is uniCloud?

uniCloud is a DCloud-built serverless cloud development platform optimized for JavaScript, with deep integration with Alibaba Cloud and Tencent Cloud.

Evolution Context

Traditional monolithic applications combined front-end and back-end code. Later, front-end/back-end separation became standard to scale teams and projects. Serverless architecture emerged to reduce operational overhead and back-end boilerplate—uniCloud brings this model to the uniApp ecosystem, letting front-end developers access cloud resources directly with minimal setup.

---

Core uniCloud Concepts

Service Space

A service space is an isolated, fully managed cloud environment containing all resources needed for an app: cloud database, object storage, cloud functions, etc. Each space has a unique spaceId; inter-space resource access is blocked by default. Both Alibaba Cloud and Tencent Cloud offer free entry-level service spaces, though advanced Tencent Cloud features are paid.

Cloud Database

uniCloud standardizes document database access across Alibaba Cloud and Tencent Cloud. Alibaba Cloud uses MongoDB 4.0 directly, while Tencent Cloud provdies a MongoDB 4.0-compatible in-house solution. Developers familiar with MongoDB will adapt quickly.

There are two primary database access paths:

1. Cloud Functions: Traditional Node.js-based backend logic, using raw or wrapped MongoDB APIs.
2. ClientDB: Direct front-end database access using JQL (JSON Query Language), with built-in schema validation and field-level permissions. This is the recommended path for rapid development, eliminating most server-side boilerplate.

Cloud Functions

Cloud functions are stateless Node.js scripts that execute in uniCloud’s managed environment. They integrate seamlessly with uniApp’s front-end APIs and cloud database, replacing much of a traditional back-end stack. This lowers the barrier to full-stack development for front-end engineers.

---

Practical ClientDB Examples

First, initialize the database instance:

const cloudDb = uniCloud.database();

Insert Data

const formPayload = {
  farm_name: '',
  farm_size: 0,
  notes: '',
  created_at: Date.now()
};

cloudDb.collection('farm_records')
  .add(formPayload)
  .then((response) => {
    uni.showToast({ icon: 'success', title: 'Record Saved' });
  })
  .catch((error) => {
    uni.showModal({ title: 'Error', content: error.message || 'Service Unavailable', showCancel: false });
  })
  .finally(() => {
    uni.hideLoading();
  });

Update Data

const recordId = '60c1234a5b67890001def234';
const updatedData = { farm_size: 120 };

cloudDb.collection('farm_records')
  .doc(recordId)
  .update(updatedData)
  .then((response) => {
    uni.showToast({ icon: 'success', title: 'Record Updated' });
  })
  .catch((error) => {
    uni.showModal({ title: 'Error', content: error.message || 'Service Unavailable', showCancel: false });
  })
  .finally(() => {
    uni.hideLoading();
  });

Delete Data

const targetId = '60c1234a5b67890001def234';

cloudDb.collection('farm_records')
  .doc(targetId)
  .remove()
  .then(() => {
    uni.showToast({ icon: 'success', title: 'Record Deleted' });
  })
  .catch((error) => {
    uni.showModal({ title: 'Error', content: error.message, showCancel: false });
  });

Query Data

Single Table Query

cloudDb.collection('farm_records')
  .where({
    farm_size: cloudDb.command.gte(100)
  })
  .orderBy('created_at', 'desc')
  .limit(20)
  .get()
  .then((result) => {
    const records = result.result.data;
    // Process records
  })
  .catch((error) => {
    console.error('Query failed:', error.code, error.message);
  });

Join Query

Set up a foreign key in the main table schema first:

{
  "crop_type_id": {
    "bsonType": "string",
    "description": "ID linking to crop type reference",
    "foreignKey": "crop_types._id"
  }
}

Then execute the join query:

const currentUserId = 'user-123abc';

cloudDb.collection('farm_records,crop_types')
  .where({ created_by: currentUserId })
  .field('crop_type_id{crop_name},farm_name,farm_size')
  .groupBy('crop_type_id')
  .groupField('count(*) as total_farms,sum(farm_size) as combined_area')
  .get()
  .then((result) => {
    const stats = result.result.data;
    // Render statistics
  })
  .catch((error) => {
    uni.showModal({ title: 'Error', content: error.message || 'Failed to load stats', showCancel: false });
  })
  .finally(() => {
    uni.hideLoading();
  });

---

uniCloud Pros and Cons

Advantages

• Reduces development time for lightweight apps by eliminating traditional back-end setup and API boilerplate
• Lowers operational and personnel costs for small projects or teams
• Enables front-end developers to build full-stack uniApp applications with minimal additional learning
• Free entry-level service spaces reduce initial infrastructure investment

Limitations

• Documentation can be disorganized, with few real-world complex examples
• Multi-table join performance and flexibility are limited, especially for advanced statistical reports
• Direct cloud database deletion via console is unavailable; requires API or cloud function calls
• No equivalent to MySQL’s query analyzer, making debugging complex JQL statements difficult
• Developers accustomed to relational databases and tools like Navicat may find the document database workflow awkward

---

Alternative: Traditional Backend with Alibaba Cloud Database

If you prefer full control over your back-end stack, here’s a simplified traditional setup:

1. Provision Alibaba Cloud Database: Create a MySQL, PostgreSQL, or other database instance via the Alibaba Cloud console, and note its connection details (host, port, username, password, database name).
2. Build a Backend Service: Choose a framework like Node.js + Express, Spring Boot, or Flask/Django to handle API requests and database communication. Example Node.js + Express backend:

   const express = require('express');
   const mysql2 = require('mysql2/promise');
   const app = express();
   const PORT = process.env.PORT || 3001;
   
   // Database connection pool
   const pool = mysql2.createPool({
     host: 'your-aliyun-db-host',
     port: 3306,
     user: 'your-db-username',
     password: 'your-db-password',
     database: 'your-db-name',
     waitForConnections: true,
     connectionLimit: 10,
     queueLimit: 0
   });
   
   // Sample API endpoint
   app.get('/api/farm-stats', async (req, res) => {
     try {
       const [rows] = await pool.query(`
         SELECT ct.crop_name, COUNT(fr.id) as total_farms, SUM(fr.farm_size) as combined_area
         FROM farm_records fr
         JOIN crop_types ct ON fr.crop_type_id = ct.id
         WHERE fr.created_by = ?
         GROUP BY ct.crop_name
       `, [req.query.user_id]);
       res.json(rows);
     } catch (error) {
       res.status(500).json({ error: 'Database query failed' });
     }
   });
   
   app.listen(PORT, () => {
     console.log(`Backend running on port ${PORT}`);
   });
   

3. Deploy Backend: Host the service on Alibaba Cloud ECS, Container Service for Kubernetes (ACK), or Function Compute.
4. Call API from UniApp: Use uni.request to communicate with your backend:

   uni.request({
     url: 'https://your-backend-domain.com/api/farm-stats',
     method: 'GET',
     data: { user_id: 'user-123abc' },
     success: (response) => {
       console.log('Fetched stats:', response.data);
     },
     fail: (error) => {
       console.error('API request failed:', error);
     }
   });
   

Back-end code resides in a separate repository and is deployed independently of the uniApp front-end.