@base44-preview/cli 0.0.44-pr.395.f527fa6 → 0.0.44-pr.406.b97f4ba

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(),
+  type: exports_external.string().optional(),
   title: exports_external.string().optional(),
   description: exports_external.string().optional(),
   minLength: exports_external.number().int().min(0).optional(),
@@ -248424,7 +248424,7 @@ function getTypesCommand(context) {
 // src/cli/dev/dev-server/main.ts
 import { dirname as dirname13, join as join18 } from "node:path";
 var import_cors = __toESM(require_lib4(), 1);
-var import_express4 = __toESM(require_express(), 1);
+var import_express6 = __toESM(require_express(), 1);
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -248779,162 +248779,19 @@ function createFunctionRouter(manager, logger) {
   return router;
 }
 
-// src/cli/dev/dev-server/db/database.ts
+// src/cli/dev/dev-server/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) {
-    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);
+  initCollections(names) {
+    for (const name2 of names) {
+      this.collections.set(name2, new import_nedb.default);
     }
   }
+  hasCollection(name2) {
+    return this.collections.has(name2);
+  }
   getCollection(name2) {
     return this.collections.get(name2);
   }
@@ -248946,25 +248803,6 @@ 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);
   }
 }
 
@@ -249000,8 +248838,8 @@ function broadcastEntityEvent(io6, appId, entityName, event) {
   });
 }
 
-// src/cli/dev/dev-server/routes/entities.ts
-var import_express2 = __toESM(require_express(), 1);
+// src/cli/dev/dev-server/routes/entities/entities-router.ts
+var import_express3 = __toESM(require_express(), 1);
 
 // ../../node_modules/nanoid/index.js
 import { webcrypto as crypto } from "node:crypto";
@@ -249033,7 +248871,52 @@ function nanoid3(size = 21) {
   return id2;
 }
 
-// src/cli/dev/dev-server/routes/entities.ts
+// src/cli/dev/dev-server/routes/entities/entities-user-router.ts
+var import_express2 = __toESM(require_express(), 1);
+
+// src/cli/dev/dev-server/routes/entities/utils.ts
+function stripInternalFields(doc2) {
+  if (Array.isArray(doc2)) {
+    return doc2.map((d5) => stripInternalFields(d5));
+  }
+  const { _id, ...rest } = doc2;
+  return rest;
+}
+
+// src/cli/dev/dev-server/routes/entities/entities-user-router.ts
+async function createUserRouter(db2) {
+  if (!db2.hasCollection("User")) {
+    db2.initCollections(["User"]);
+  }
+  const userInfo = await readAuth();
+  const now = new Date().toISOString().replace("Z", "000");
+  const idMe = nanoid3();
+  await db2.getCollection("User")?.insertAsync({
+    id: idMe,
+    email: userInfo.email,
+    full_name: userInfo.name,
+    is_service: false,
+    is_verified: true,
+    disabled: null,
+    role: "admin",
+    collaborator_role: "editor",
+    created_date: now,
+    updated_date: now
+  });
+  const router = import_express2.Router({ mergeParams: true });
+  router.get("/:id", async (req, res) => {
+    const id2 = req.params.id === "me" ? idMe : req.params.id;
+    const result = await db2.getCollection("User")?.findOneAsync({ id: id2 });
+    if (!result) {
+      res.status(404).json({ error: `User with id "${req.params.id}" not found` });
+      return;
+    }
+    res.json(stripInternalFields(result));
+  });
+  return router;
+}
+
+// src/cli/dev/dev-server/routes/entities/entities-router.ts
 function parseSort(sort) {
   if (!sort) {
     return;
@@ -249056,16 +248939,9 @@ function parseFields(fields) {
   }
   return Object.keys(projection).length > 0 ? projection : undefined;
 }
-function stripInternalFields(doc2) {
-  if (Array.isArray(doc2)) {
-    return doc2.map((d5) => stripInternalFields(d5));
-  }
-  const { _id, ...rest } = doc2;
-  return rest;
-}
-function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
-  const router = import_express2.Router({ mergeParams: true });
-  const parseBody = import_express2.json();
+async function createEntityRoutes(db2, logger, broadcast) {
+  const router = import_express3.Router({ mergeParams: true });
+  const parseBody = import_express3.json();
   function withCollection(handler) {
     return async (req, res) => {
       const collection = db2.getCollection(req.params.entityName);
@@ -249091,11 +248967,8 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
     }
     broadcast(appId, entityName, createData(data));
   }
-  router.get("/User/:id", (req, res, next) => {
-    logger.warn(`"${req.originalUrl}" is not supported in local development, passing call to production`);
-    req.url = req.originalUrl;
-    remoteProxy(req, res, next);
-  });
+  const userRouter = await createUserRouter(db2);
+  router.use("/User", userRouter);
   router.get("/:entityName/:id", withCollection(async (req, res, collection) => {
     const { entityName, id: id2 } = req.params;
     try {
@@ -249156,14 +249029,8 @@ 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 = {
-        ...filteredBody,
+        ...body,
         id: nanoid3(),
         created_date: now,
         updated_date: now
@@ -249184,21 +249051,12 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
     }
     try {
       const now = new Date().toISOString();
-      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 records = req.body.map((item) => ({
+        ...item,
+        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);
@@ -249211,14 +249069,8 @@ 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 = {
-        ...filteredBody,
+        ...body,
         updated_date: new Date().toISOString()
       };
       const result = await collection.updateAsync({ id: id2 }, { $set: updateData }, { returnUpdatedDocs: true });
@@ -249267,7 +249119,7 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
 }
 
 // src/cli/dev/dev-server/routes/integrations.ts
-var import_express3 = __toESM(require_express(), 1);
+var import_express4 = __toESM(require_express(), 1);
 var import_multer = __toESM(require_multer(), 1);
 import { createHash, randomUUID as randomUUID4 } from "node:crypto";
 import fs28 from "node:fs";
@@ -249276,8 +249128,8 @@ function createFileToken(fileUri) {
   return createHash("sha256").update(fileUri).digest("hex");
 }
 function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
-  const router = import_express3.Router({ mergeParams: true });
-  const parseBody = import_express3.json();
+  const router = import_express4.Router({ mergeParams: true });
+  const parseBody = import_express4.json();
   const privateFilesDir = path18.join(mediaFilesDir, "private");
   fs28.mkdirSync(mediaFilesDir, { recursive: true });
   fs28.mkdirSync(privateFilesDir, { recursive: true });
@@ -249347,7 +249199,7 @@ function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
   return router;
 }
 function createCustomIntegrationRoutes(remoteProxy, logger) {
-  const router = import_express3.Router({ mergeParams: true });
+  const router = import_express4.Router({ mergeParams: true });
   router.post("/:slug/:operationId", (req, res, next) => {
     logger.warn(`"${req.originalUrl}" is not supported in local development, passing call to production`);
     req.url = req.originalUrl;
@@ -249356,6 +249208,18 @@ function createCustomIntegrationRoutes(remoteProxy, logger) {
   return router;
 }
 
+// src/cli/dev/dev-server/routes/users.ts
+var import_express5 = __toESM(require_express(), 1);
+function createUsersRoutes() {
+  const router = import_express5.Router({ mergeParams: true });
+  const parseBody = import_express5.json();
+  router.post("/invite-user", parseBody, (req, _res, next) => {
+    console.log("invite-user", req.body);
+    next();
+  });
+  return router;
+}
+
 // src/cli/dev/dev-server/watcher.ts
 import { EventEmitter as EventEmitter4 } from "node:events";
 import { relative as relative6 } from "node:path";
@@ -251060,7 +250924,7 @@ async function createDevServer(options8) {
   const port = userPort ?? await getPorts({ port: DEFAULT_PORT });
   const baseUrl = `http://localhost:${port}`;
   const { functions, entities, project: project2 } = await options8.loadResources();
-  const app = import_express4.default();
+  const app = import_express6.default();
   const remoteProxy = import_http_proxy_middleware2.createProxyMiddleware({
     target: BASE44_APP_URL,
     changeOrigin: true
@@ -251077,7 +250941,17 @@ async function createDevServer(options8) {
     }
     next();
   });
+  app.use((req, res, next) => {
+    const auth2 = req.headers.authorization;
+    if (!auth2 || !auth2.startsWith("Bearer ")) {
+      res.status(401).json({ error: "Unauthorized" });
+      return;
+    }
+    next();
+  });
   const devLogger = createDevLogger();
+  const usersRoutes = createUsersRoutes();
+  app.use("/api/apps/:appId/users", usersRoutes);
   const functionManager = new FunctionManager(functions, devLogger, options8.denoWrapperPath);
   const functionRoutes = createFunctionRouter(functionManager, devLogger);
   app.use("/api/apps/:appId/functions", functionRoutes);
@@ -251085,12 +250959,12 @@ async function createDevServer(options8) {
     R2.info(`Loaded functions: ${functionManager.getFunctionNames().join(", ")}`);
   }
   const db2 = new Database;
-  db2.load(entities);
+  db2.initCollections(entities.map((entity2) => entity2.name));
   if (db2.getCollectionNames().length > 0) {
     R2.info(`Loaded entities: ${db2.getCollectionNames().join(", ")}`);
   }
   let emitEntityEvent = () => {};
-  const entityRoutes = createEntityRoutes(db2, devLogger, remoteProxy, (...args) => emitEntityEvent(...args));
+  const entityRoutes = await createEntityRoutes(db2, devLogger, (...args) => emitEntityEvent(...args));
   app.use("/api/apps/:appId/entities", entityRoutes);
   const { path: mediaFilesDir } = await $dir();
   app.use("/media/private/:fileUri", (req, res, next) => {
@@ -251111,7 +250985,7 @@ async function createDevServer(options8) {
     }
     next();
   });
-  app.use("/media", import_express4.default.static(mediaFilesDir));
+  app.use("/media", import_express6.default.static(mediaFilesDir));
   const integrationRoutes = createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, devLogger);
   app.use("/api/apps/:appId/integration-endpoints", integrationRoutes);
   const customIntegrationRoutes = createCustomIntegrationRoutes(remoteProxy, devLogger);
@@ -251160,7 +251034,7 @@ async function createDevServer(options8) {
         if (previousEntityCount > 0) {
           devLogger.log("Entities directory changed, clearing data...");
         }
-        db2.load(entities2);
+        db2.initCollections(entities2.map((entity2) => entity2.name));
         if (db2.getCollectionNames().length > 0) {
           devLogger.log(`Loaded entities: ${db2.getCollectionNames().join(", ")}`);
         }
@@ -255561,4 +255435,4 @@ export {
   CLIExitError
 };
 
-//# debugId=9474DF9F31ED113764756E2164756E21
+//# debugId=6ACA581A680E964E64756E2164756E21