@xuda.io/runtime-bundle 1.0.1216 → 1.0.1217

package/js/modules/xuda-studio-checker.mjs

@@ -235,6 +235,19 @@ export const check_structure = function (doc) {
     return ret;
   }
 
+  if (z) {
+    const schema = get_zod_schema(doc.properties.menuType);
+    const result = schema.safeParse(doc);
+    if (!result.success) {
+      result.error.errors.forEach((error) => {
+        const msg = `${error.message}: ${error.path}(${error.expected})`;
+        addValidationError('CHK_MSG_OBJ_GEN_000', msg);
+      });
+      critical_error = true;
+      return ret;
+    }
+  }
+
   // Continue validation even with errors
   if (!doc._id) {
     addValidationError('CHK_MSG_OBJ_GEN_050', 'missing _id value');
@@ -3733,7 +3746,57 @@ export const get_zod_schema = function (type) {
 
   let XudaComponentSchema = z.object(main_obj);
 
+  main_obj.properties = properties;
+
   switch (type) {
+    case `globals`:
+      XudaComponentSchema.describe(
+        `The globals object in the Xuda platform defines a universal logic layer shared across all programs, components, and workflows. It provides a centralized and consistent structure for declaring global fields, utility functions, and event-driven logic, ensuring logic reusability and reducing redundancy across the application.`,
+      );
+      main_obj.progFields = progFields;
+      main_obj.progEvents = progEvents;
+      break;
+
+    case `table`:
+      XudaComponentSchema.describe(
+        `The Table Object represents a data entity and serves as the structural definition for interacting with external databases. It supports integration via pluggable connectors, allowing seamless connection to various database engines such as MySQL, CouchDB, and others (see available database plugins for the full list).`,
+      );
+      properties_obj.databaseSocket = z.string().default('@xuda.io/xuda-dbs-plugin-xuda').describe('Database driver to use for the table');
+
+      const XudaFieldType = z.enum(['string', 'number', 'boolean', 'array', 'object', 'date']).describe('Data type for table fields');
+      const IndexDataSchema = z.object({
+        name: z.string().describe('Name of the index'),
+        unique: z.boolean().describe('If true, ensures no duplicates for indexed fields'),
+        keys: z.array(z.string()).describe('List of field names used in this index'),
+      });
+
+      const TableIndexSchema = z.object({
+        id: z.string().describe('Unique identifier for the index'),
+        data: IndexDataSchema.describe('Contains keys, uniqueness setting, and index name'),
+      });
+
+      const FieldPropsSchema = z.object({
+        fieldType: XudaFieldType.describe('Data type: "string", "number", "boolean", "array", "object", or "date"'),
+      });
+      const FieldDataSchema = z.object({
+        field_id: z.string().describe('Field identifier used in logic or database operations'),
+      });
+      const TableFieldSchema = z.object({
+        id: z.string().describe('Unique ID of the field object'),
+        data: FieldDataSchema.describe('Contains the logical field ID'),
+        props: FieldPropsSchema.describe('Properties of the field including data type'),
+      });
+      main_obj.tableIndexes = z.array(TableIndexSchema).describe('Defines indexing rules for efficient lookups and uniqueness constraints');
+      main_obj.tableFields = z.array(TableFieldSchema).describe('Defines each field used in the table and its data type');
+      break;
+
+    case `folder`:
+      XudaComponentSchema.describe(
+        `The Folder is a non-executable, project-level container represented as a structured JSON object. It is used to define a hierarchical structure for organizing application assets within the Xuda environment. Although it does not execute any logic at runtime, the folder object plays an essential role in shaping the overall architecture of a project by logically grouping related objects such as components, APIs, tables, datasets, and other program entities.`,
+      );
+
+      break;
+
     case `component`:
       XudaComponentSchema.describe(
         `The component object in the Xuda platform defines a modular, self-contained program unit that encapsulates both front-end presentation and back-end logic. It serves as a reusable UI component that supports a full execution lifecycle, making it ideal for constructing low-code applications that are maintainable, scalable, and highly interactive. A component is engineered to allow seamless integration of logic, data, and rendering, enabling developers to build sophisticated interactive views without redundant code. Each component instance supports input/output parameters, can communicate with other components or programs, and can be dynamically rendered as a page, modal, or embedded panel.`,
@@ -3745,7 +3808,7 @@ export const get_zod_schema = function (type) {
       properties_obj.menuTitle = z.string().optional().describe(`Display title for Studio UI or routing usage`);
       properties_obj.progParams = z.array(ProgParamSchema).optional().describe(`Array of input/output parameter definitions for ${type} interface`);
 
-      main_obj.properties = properties;
+      // main_obj.properties = properties;
       main_obj.progDataSource = progDataSource;
       main_obj.progFields = progFields;
       main_obj.progEvents = progEvents;
@@ -3753,30 +3816,87 @@ export const get_zod_schema = function (type) {
 
       break;
 
-    default:
+    case `get_data`:
+      XudaComponentSchema.describe(
+        `The Get Data Object defines a lightweight, read-only program unit designed to retrieve data from a structured source such as a table, array, or remote dataset. It is used to extract specific values, perform indexed lookups, and support transformations through reduce or conditional logic. This object is typically used when a logic program requires only data retrieval without the need to iterate or mutate records. It supports output parameter mapping and can be embedded into workflows and alerts for dynamic value extraction.`,
+      );
+      properties_obj.frameworkProperties = z.object({}).optional().describe(`Framework-specific rendering extensions and configuration`);
+      properties_obj.progParams = z.array(ProgParamSchema).optional().describe(`Array of input/output parameter definitions for ${type} interface`);
+      // main_obj.properties = properties;
+      main_obj.progDataSource = progDataSource;
+      main_obj.progFields = progFields;
+      main_obj.progEvents = progEvents;
       break;
-  }
 
-  // Validation helper functions
-  const validateXudaComponent = (data) => {
-    try {
-      return {
-        success: true,
-        data: XudaComponentSchema.parse(data),
-        errors: null,
-      };
-    } catch (error) {
-      return {
-        success: false,
-        data: null,
-        errors: error.errors,
-      };
-    }
-  };
+    case `set_data`:
+      XudaComponentSchema.describe(
+        `The set_data object defines a program-level functional unit responsible for writing data to a specified table. It can be invoked from any program and is designed to handle create, update, and delete operations in a structured and reusable way. The object includes properties to determine the type of operation being performed and supports an optional flag to create a new record if one does not already exist. In addition to its core structure, the set_data object includes a parameter interface property that defines input and output parameters. This allows values to be passed into the function and returned to the calling context, enabling flexible, context-aware data handling.`,
+      );
+      properties_obj.progParams = z.array(ProgParamSchema).optional().describe(`Array of input/output parameter definitions for ${type} interface`);
 
-  const safeParse = (schema, data) => {
-    return schema.safeParse(data);
-  };
+      properties_obj.crudMode = z.enum(['C', 'U', 'D']).describe('Operation mode: C = Create, U = Update, D = Delete');
+      properties_obj.crudMode = z.boolean().describe('If true, allows record creation if not found');
+
+      main_obj.progDataSource = progDataSource;
+      main_obj.progFields = progFields;
+      main_obj.progEvents = progEvents;
+      break;
+
+    case `batch`:
+      XudaComponentSchema.describe(
+        `The Batch Object defines a program-level execution unit tailored for iterative, record-by-record operations across datasets. It enables controlled loops over structured data sources or arrays, making it a foundational element for multi-record processing, automation flows, and background job orchestration. The batch object can be invoked from within any Xuda logic program and serves as a reusable execution block for bulk workflows, such as saving multiple records, transforming arrays, or triggering chained program logic. It accepts dynamic input and output parameters, which allow context-aware execution and return values that can be consumed downstream.The batch unit also includes lifecycle hooks and event workflow, enabling custom logic at specific points within the loop (e.g., before/after each record or on error conditions). This supports advanced control, transformation, and external interactions during iterative processing.`,
+      );
+      properties_obj.progParams = z.array(ProgParamSchema).optional().describe(`Array of input/output parameter definitions for ${type} interface`);
+      main_obj.progDataSource = progDataSource;
+      main_obj.progFields = progFields;
+      main_obj.progEvents = progEvents;
+      break;
+
+    case `api`:
+      XudaComponentSchema.describe(
+        `The API Program-Level Logic Unit is a program-level logic unit represented as a structured JSON object that exposes backend functionality through internal or external interfaces. It can be invoked internally via the call_project_api method or externally through the api/mcp endpoint, enabling controlled access to application-level logic and data services. Acting as an orchestration layer, the API unit enables coordination of multiple subordinate logic units such as get_data, set_data, and batch, allowing compound workflows, transactional operations, and conditional executions to be encapsulated within a single, callable endpoint. This design abstracts complexity and promotes composability of business logic across the application. The API unit includes an interface definition for parameter binding, specifying dynamic input and output mappings. This supports stateless, context-aware executions where external values can be passed into the API call, and structured results returned to the calling layer. Response format configuration is also supported, with output types including json, text, html, and others—allowing precise control over the serialization and consumption of API responses.`,
+      );
+      properties_obj.progParams = z.array(ProgParamSchema).optional().describe(`Array of input/output parameter definitions for ${type} interface`);
+      const ApiOutputFormat = z.enum(['json', 'html', 'text', 'xml', 'csv', 'pdf']).describe('Format of the API response: json, html, text, xml, csv, pdf, etc.');
+      properties_obj.apiOutput = ApiOutputFormat.describe('Format of the API response: json, html, text, etc.');
+
+      main_obj.progDataSource = progDataSource;
+      main_obj.progFields = progFields;
+      main_obj.progEvents = progEvents;
+      main_obj.scriptData = z.object({
+        value: z.string().describe('The return payload template as a stringified object. Placeholder bindings (e.g., @CS_Id) are replaced at runtime'),
+      });
+
+      break;
+
+    case `alert`:
+      XudaComponentSchema.describe(
+        `The Alert Object is a program-level UI unit in the Xuda platform used to deliver contextual messages and notifications to users or developers at runtime. These alerts can be triggered from within logic flows and offer various display formats (such as toast, modal, browser alert, or console message) based on the use case. The alert object is defined using a structured JSON format and can be embedded in broader program logic. It supports both static and dynamic content, and can optionally create log entries to support audit trails and debugging workflows.`,
+      );
+      properties_obj.progParams = z.array(ProgParamSchema).optional().describe(`Array of input/output parameter definitions for ${type} interface`);
+      main_obj.alertData = z.object({
+        alertDisplay: AlertDisplay.describe('Mode of display: "toast", "modal", "browser", or "console"'),
+        alertType: AlertType.describe('Type of message: "warning", "error", "info", or "success"'),
+        alertTitle: z.string().describe('Main content of the alert shown to the user'),
+        alertTitleFx: z.string().optional().describe('Optional dynamic override (e.g., @msg_v) for alert content'),
+        createLog: z.boolean().describe('Whether to generate a system log entry associated with the alert'),
+      });
+      break;
+
+    case `javascript`:
+      XudaComponentSchema.describe(
+        `The javascript object is a functional unit designed to execute JavaScript code within the application context. It can be called from any program using methods such as call_native_javascript, call_evaluate_javascript, execute_native_javascript, or execute_evaluate_javascript. This object includes the following key property: Script – Contains the JavaScript code to be executed, along with any declared dependencies required for execution. The javascript object is ideal for performing advanced logic, custom client-side behavior, or dynamic scripting that extends the capabilities of low-code flows. Xuda also exposes a set of built-in API methods that can be easily called from JavaScript units. These include actions like reading from or writing to Drive, interacting with the Studio API, or performing database operations such as create, update, and delete. These ready-to-use APIs simplify common tasks and allow you to focus on building functionality instead of writing boilerplate code. By centralizing script execution in a modular and reusable way, the JavaScript unit enhances flexibility, promotes clean architecture, and empowers developers to go beyond standard configuration with native scripting power.`,
+      );
+      properties_obj.progParams = z.array(ProgParamSchema).optional().describe(`Array of input/output parameter definitions for ${type} interface`);
+      main_obj.scriptData = z.object({
+        value: z.string().describe('JavaScript code to be executed'),
+        dependencies: z.record(z.string()).optional().describe('Optional. Key-value map of external packages required'),
+      });
+      break;
+
+    default:
+      break;
+  }
 
   return XudaComponentSchema;
 };

package/js/xuda-runtime-bundle.js

@@ -26808,6 +26808,9 @@ func.utils.remove_cached_objects = async function (SESSION_ID) {
         {
           docType: 'cache_app',
         },
+        {
+          docType: 'cache_build_info',
+        },
       ],
     };