@base44-preview/cli 0.0.44-pr.380.71fe077 → 0.0.44-pr.395.7152e38

package/dist/cli/index.js

@@ -238081,7 +238081,7 @@ var FieldRLSSchema = exports_external.looseObject({
   delete: RLSRuleSchema.optional()
 });
 var PropertyDefinitionSchema = exports_external.looseObject({
-  type: exports_external.string().optional(),
+  type: exports_external.string(),
   title: exports_external.string().optional(),
   description: exports_external.string().optional(),
   minLength: exports_external.number().int().min(0).optional(),
@@ -238236,22 +238236,6 @@ var DeployFunctionsResponseSchema = exports_external.object({
   skipped: exports_external.array(exports_external.string()).optional().nullable(),
   errors: exports_external.array(exports_external.object({ name: exports_external.string(), message: exports_external.string() })).nullable()
 });
-var FunctionInfoSchema = exports_external.object({
-  name: exports_external.string(),
-  deployment_id: exports_external.string(),
-  entry: exports_external.string(),
-  files: exports_external.array(FunctionFileSchema),
-  automations: exports_external.array(AutomationSchema)
-}).transform((data) => ({
-  name: data.name,
-  deploymentId: data.deployment_id,
-  entry: data.entry,
-  files: data.files,
-  automations: data.automations
-}));
-var ListFunctionsResponseSchema = exports_external.object({
-  functions: exports_external.array(FunctionInfoSchema)
-});
 var LogLevelSchema = exports_external.enum(["info", "warning", "error", "debug"]);
 var FunctionLogEntrySchema = exports_external.object({
   time: exports_external.string(),
@@ -238325,20 +238309,6 @@ async function fetchFunctionLogs(functionName, filters = {}) {
   }
   return result.data;
 }
-async function listDeployedFunctions() {
-  const appClient = getAppClient();
-  let response;
-  try {
-    response = await appClient.get("backend-functions", { timeout: 30000 });
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "listing deployed functions");
-  }
-  const result = ListFunctionsResponseSchema.safeParse(await response.json());
-  if (!result.success) {
-    throw new SchemaValidationError("Invalid response from server", result.error);
-  }
-  return result.data;
-}
 // src/core/resources/function/config.ts
 import { basename as basename2, dirname as dirname3, join as join5, relative } from "node:path";
 async function readFunctionConfig(configPath) {
@@ -247620,36 +247590,10 @@ async function deployFunctionsAction() {
   }
   return { outroMessage: "Functions deployed to Base44" };
 }
-function getDeployCommand(context) {
-  return new Command("deploy").description("Deploy local functions to Base44").action(async () => {
+function getFunctionsDeployCommand(context) {
+  return new Command("functions").description("Manage project functions").addCommand(new Command("deploy").description("Deploy local functions to Base44").action(async () => {
     await runCommand(deployFunctionsAction, { requireAuth: true }, context);
-  });
-}
-
-// src/cli/commands/functions/list.ts
-async function listFunctionsAction() {
-  const { functions } = await runTask("Fetching functions...", async () => listDeployedFunctions());
-  if (functions.length === 0) {
-    return { outroMessage: "No functions on remote" };
-  }
-  for (const fn of functions) {
-    const automationCount = fn.automations.length;
-    const automationLabel = automationCount > 0 ? theme.styles.dim(` (${automationCount} automation${automationCount > 1 ? "s" : ""})`) : "";
-    R2.message(`  ${fn.name}${automationLabel}`);
-  }
-  return {
-    outroMessage: `${functions.length} function${functions.length !== 1 ? "s" : ""} on remote`
-  };
-}
-function getListCommand(context) {
-  return new Command("list").description("List all deployed functions").action(async () => {
-    await runCommand(listFunctionsAction, { requireAuth: true }, context);
-  });
-}
-
-// src/cli/commands/functions/index.ts
-function getFunctionsCommand(context) {
-  return new Command("functions").description("Manage backend functions").addCommand(getDeployCommand(context)).addCommand(getListCommand(context));
+  }));
 }
 
 // src/cli/commands/project/create.ts
@@ -247887,7 +247831,7 @@ ${summaryLines.join(`
   }
   return { outroMessage: "App deployed successfully" };
 }
-function getDeployCommand2(context) {
+function getDeployCommand(context) {
   return new Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
     await runCommand(() => deployAction({
       ...options,
@@ -248835,14 +248779,163 @@ function createFunctionRouter(manager, logger) {
   return router;
 }
 
-// src/cli/dev/dev-server/database.ts
+// src/cli/dev/dev-server/db/database.ts
 var import_nedb = __toESM(require_nedb(), 1);
 
+// src/cli/dev/dev-server/db/validator.ts
+var fieldTypes = [
+  "string",
+  "integer",
+  "number",
+  "boolean",
+  "array",
+  "object"
+];
+
+class Validator {
+  filterFields(record2, entitySchema) {
+    const filteredRecord = {};
+    for (const [key2, value] of Object.entries(record2)) {
+      if (entitySchema.properties[key2]) {
+        filteredRecord[key2] = value;
+      }
+    }
+    return filteredRecord;
+  }
+  applyDefaults(record2, entitySchema) {
+    const result = {};
+    for (const [key2, property] of Object.entries(entitySchema.properties)) {
+      if (property.default !== undefined) {
+        result[key2] = property.default;
+      }
+    }
+    return {
+      ...result,
+      ...record2
+    };
+  }
+  validate(record2, entitySchema, partial2 = false) {
+    if (!partial2) {
+      const requiredFieldsResponse = this.validateRequiredFields(record2, entitySchema);
+      if (requiredFieldsResponse.hasError) {
+        return requiredFieldsResponse;
+      }
+    }
+    const fieldTypesResponse = this.validateFieldTypes(record2, entitySchema);
+    if (fieldTypesResponse.hasError) {
+      return fieldTypesResponse;
+    }
+    return {
+      hasError: false
+    };
+  }
+  createValidationError(message) {
+    return {
+      error_type: "ValidationError",
+      message,
+      request_id: null,
+      traceback: ""
+    };
+  }
+  validateFieldTypes(record2, entitySchema) {
+    for (const [key2, value] of Object.entries(record2)) {
+      const property = entitySchema.properties[key2];
+      const result = this.validateValue(value, property, key2);
+      if (result.hasError)
+        return result;
+    }
+    return {
+      hasError: false
+    };
+  }
+  validateValue(value, property, fieldPath) {
+    if (!property) {
+      return { hasError: false };
+    }
+    const propertyType = property.type;
+    if (!fieldTypes.includes(propertyType)) {
+      return {
+        hasError: true,
+        error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid ${propertyType}`)
+      };
+    }
+    switch (propertyType) {
+      case "array":
+        if (!Array.isArray(value)) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid array`)
+          };
+        }
+        if (property.items) {
+          for (let i5 = 0;i5 < value.length; i5++) {
+            const itemResult = this.validateValue(value[i5], property.items, `${fieldPath}[${i5}]`);
+            if (itemResult.hasError)
+              return itemResult;
+          }
+        }
+        break;
+      case "object":
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid object`)
+          };
+        }
+        if (property.properties) {
+          for (const [subKey, subValue] of Object.entries(value)) {
+            if (property.properties[subKey]) {
+              const subResult = this.validateValue(subValue, property.properties[subKey], `${fieldPath}.${subKey}`);
+              if (subResult.hasError)
+                return subResult;
+            }
+          }
+        }
+        break;
+      case "integer":
+        if (!Number.isInteger(value)) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid integer`)
+          };
+        }
+        break;
+      default:
+        if (typeof value !== propertyType) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid ${propertyType}`)
+          };
+        }
+    }
+    return { hasError: false };
+  }
+  validateRequiredFields(record2, entitySchema) {
+    if (entitySchema.required && entitySchema.required.length > 0) {
+      for (const required2 of entitySchema.required) {
+        if (record2[required2] == null) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${required2}: Field required`)
+          };
+        }
+      }
+    }
+    return {
+      hasError: false
+    };
+  }
+}
+
+// src/cli/dev/dev-server/db/database.ts
 class Database {
   collections = new Map;
+  schemas = new Map;
+  validator = new Validator;
   load(entities) {
     for (const entity2 of entities) {
       this.collections.set(entity2.name, new import_nedb.default);
+      this.schemas.set(entity2.name, entity2);
     }
   }
   getCollection(name2) {
@@ -248856,6 +248949,25 @@ class Database {
       collection.remove({}, { multi: true });
     }
     this.collections.clear();
+    this.schemas.clear();
+  }
+  validate(entityName, record2, partial2 = false) {
+    const schema9 = this.schemas.get(entityName);
+    if (!schema9) {
+      throw new Error(`Entity "${entityName}" not found`);
+    }
+    return this.validator.validate(record2, schema9, partial2);
+  }
+  prepareRecord(entityName, record2, partial2 = false) {
+    const schema9 = this.schemas.get(entityName);
+    if (!schema9) {
+      throw new Error(`Entity "${entityName}" not found`);
+    }
+    const filteredRecord = this.validator.filterFields(record2, schema9);
+    if (partial2) {
+      return filteredRecord;
+    }
+    return this.validator.applyDefaults(filteredRecord, schema9);
   }
 }
 
@@ -249047,8 +249159,14 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
     try {
       const now = new Date().toISOString();
       const { _id, ...body } = req.body;
+      const filteredBody = db2.prepareRecord(entityName, body);
+      const validation = db2.validate(entityName, filteredBody);
+      if (validation.hasError) {
+        res.status(422).json(validation.error);
+        return;
+      }
       const record2 = {
-        ...body,
+        ...filteredBody,
         id: nanoid3(),
         created_date: now,
         updated_date: now
@@ -249069,12 +249187,21 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
     }
     try {
       const now = new Date().toISOString();
-      const records = req.body.map((item) => ({
-        ...item,
-        id: nanoid3(),
-        created_date: now,
-        updated_date: now
-      }));
+      const records = [];
+      for (const record2 of req.body) {
+        const filteredRecord = db2.prepareRecord(entityName, record2);
+        const validation = db2.validate(entityName, filteredRecord);
+        if (validation.hasError) {
+          res.status(422).json(validation.error);
+          return;
+        }
+        records.push({
+          ...filteredRecord,
+          id: nanoid3(),
+          created_date: now,
+          updated_date: now
+        });
+      }
       const inserted = stripInternalFields(await collection.insertAsync(records));
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
@@ -249087,8 +249214,14 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
     const { appId, entityName, id: id2 } = req.params;
     const { id: _id, created_date: _created_date, ...body } = req.body;
     try {
+      const filteredBody = db2.prepareRecord(entityName, body, true);
+      const validation = db2.validate(entityName, filteredBody, true);
+      if (validation.hasError) {
+        res.status(422).json(validation.error);
+        return;
+      }
       const updateData = {
-        ...body,
+        ...filteredBody,
         updated_date: new Date().toISOString()
       };
       const result = await collection.updateAsync({ id: id2 }, { $set: updateData }, { returnUpdatedDocs: true });
@@ -251179,13 +251312,13 @@ function createProgram(context) {
   program2.addCommand(getLogoutCommand(context));
   program2.addCommand(getCreateCommand(context));
   program2.addCommand(getDashboardCommand(context));
-  program2.addCommand(getDeployCommand2(context));
+  program2.addCommand(getDeployCommand(context));
   program2.addCommand(getLinkCommand(context));
   program2.addCommand(getEjectCommand(context));
   program2.addCommand(getEntitiesPushCommand(context));
   program2.addCommand(getAgentsCommand(context));
   program2.addCommand(getConnectorsCommand(context));
-  program2.addCommand(getFunctionsCommand(context));
+  program2.addCommand(getFunctionsDeployCommand(context));
   program2.addCommand(getSecretsCommand(context));
   program2.addCommand(getSiteCommand(context));
   program2.addCommand(getTypesCommand(context));
@@ -255431,4 +255564,4 @@ export {
   CLIExitError
 };
 
-//# debugId=FD4A53B035AEBB5D64756E2164756E21
+//# debugId=40892139B6B5F92764756E2164756E21