APIJSON No-Code ORM

APIJSON is a JSON-based internet communication protocol and an ORM (Object-Relational Mapping) library designed to simplify backend API development.

It allows developers to:

• Get data quickly: Define specific information requirements in a single request to fetch different types of data, reducing the need for multiple endpoints.
• Simplify API Design: Reduces the workload for backend developers by automating much of the API design and documentation process. This minimizes communication errors between server and client developers and helps maintain compatibility with legacy applications.
• Perform CRUD operations: Supports Create, Read, Update, and Delete operations, as well as Fuzzy Search and Remote Function Calls.

APIJSON is a real-time, no-code, powerful, and secure ORM (Object-Relational Mapping) designed to bridge the gap between backend and frontend development.

Key Value Proposition:

• Backend: Provides APIs and documentation automatically without manual coding.
• Frontend: Can customize response JSON structures directly, reducing the need for backend changes when UI requirements evolve.

It supports a vast ecosystem of databases (MySQL, PostgreSQL, Oracle, MongoDB, etc.) and multiple programming languages (Java, Go, C#, PHP, Node.js, Python, Rust, etc.).

APIJSON provides various resources to understand its capabilities:

• Features: Understand the specific benefits for both Frontend and Backend developers.
• Interface Demonstrations: See how APIJSON works in practice using tools like Postman and APIAuto.
• App Demo: View a live demonstration of the APIJSON client app.
• Presentations: Access shared talks and presentations about APIJSON.

Refer to the README for direct links to these demonstrations and feature breakdowns.

APIJSON is available across multiple programming languages and frameworks. Depending on your stack, you can use the following implementations:

• NestJS: nestjs-apijson (supports CRUD, JOIN, and various conditions for MySQL, PostgreSQL, SQLite).
• Python: uliweb-apijson (supports MySQL, PostgreSQL, SQL Server, Oracle, SQLite, etc.).
• Rust: apijson-rust (high-performance multi-datasource management for MySQL and PostgreSQL).
• Go: apijson-go-demo (provides various complexity scenarios) and apijson-go-ui (for UI configuration and permission management).
• Java/Spring: Various implementations including apijson-spring-boot (uses YAML for simplified configuration) and apijson-template (uses Gradle).
• JavaScript/TypeScript: apijson-builder (a library to help construct RESTful requests for APIJSON).

APIJSON is a JSON transmission protocol that is independent of specific programming languages like C#, Go, Java, JavaScript, PHP, Python, or TypeScript. The protocol defines how the frontend requests data and how the backend responds using a structured JSON format.

Key Protocol Rules:

• Use key~ for matching (replaces the deprecated key?).
• When using SQL functions in @column, use a semicolon ; to separate them instead of a comma (e.g., @column: "store_id;sum(amt):totAmt").
• The protocol focuses on describing data requirements (which fields, which relations, which filters) within the JSON request itself.

To simplify interacting with APIJSON from a frontend or client-side application, you can use client libraries that provide RESTful-like functions, avoiding the need to manually construct complex query JSON objects.

• apijson-builder (JavaScript): A client library providing RESTful-like functions for APIJSON.
• apijson-builder (TypeScript): A simplified TypeScript wrapper that makes constructing queries easier than direct JSON construction.

To implement custom business logic that goes beyond standard CRUD operations, you can write Remote Functions in the backend. These functions provide access to the following context to allow for custom data processing:

• session: The current user session.
• version: The API version being requested.
• The current JSON object being processed.
• Parameter names.

This allows you to intercept the data returned by the ORM and apply custom transformations or logic before it is sent to the client.

The @combine keyword allows you to define complex logical relationships between other keys in the same object. The logic follows a specific precedence:

1. The expression provided in @combine is evaluated.
2. Any other keys in the object that are NOT mentioned in @combine are treated as being connected via AND (&) to the result of the @combine expression.

Example Logic: If you have @combine: "key0 | (key1 & (key2 | !key3))", the final SQL logic is effectively: (OtherKeys) AND (key0 OR (key1 AND (key2 OR (NOT key3))))

APIJSON uses specific method naming conventions for different operation types:

• Operation Types: GETS is the functional equivalent of GET, and HEADS is the functional equivalent of HEAD. While the request syntax differs slightly, the returned results are identical.
• HTTP Transport: In all HTTP communications, the automated interface methods (get, gets, head, heads, post, put, delete) exclusively use the HTTP POST method for transport.

APIJSON allows linking data from different tables/objects using the @ operator. This is used to assign a value from one object to a field in another (e.g., User.id = Moment.userId).

• Relative Path (id@): Uses a path relative to the current container (e.g., "id@":"Moment/userId").
• Absolute Path (id@): Uses a full path starting from the root or a specific container (e.g., "momentId@":"[]/Moment/id").

{
  "Moment":{},
  "User":{
    "id@":"Moment/userId"
  }
}