@base44-preview/cli 0.0.47-pr.370.b77da88 → 0.0.47-pr.406.1043c2c

package/dist/cli/index.js

@@ -179494,19 +179494,19 @@ var require_base64id = __commonJS((exports, module) => {
   /*!
    * base64id v0.1.0
    */
-  var crypto = __require("crypto");
+  var crypto2 = __require("crypto");
   var Base64Id = function() {};
   Base64Id.prototype.getRandomBytes = function(bytes) {
     var BUFFER_SIZE = 4096;
     var self2 = this;
     bytes = bytes || 12;
     if (bytes > BUFFER_SIZE) {
-      return crypto.randomBytes(bytes);
+      return crypto2.randomBytes(bytes);
     }
     var bytesInBuffer = parseInt(BUFFER_SIZE / bytes);
     var threshold = parseInt(bytesInBuffer * 0.85);
     if (!threshold) {
-      return crypto.randomBytes(bytes);
+      return crypto2.randomBytes(bytes);
     }
     if (this.bytesBufferIndex == null) {
       this.bytesBufferIndex = -1;
@@ -179518,14 +179518,14 @@ var require_base64id = __commonJS((exports, module) => {
     if (this.bytesBufferIndex == -1 || this.bytesBufferIndex > threshold) {
       if (!this.isGeneratingBytes) {
         this.isGeneratingBytes = true;
-        crypto.randomBytes(BUFFER_SIZE, function(err, bytes2) {
+        crypto2.randomBytes(BUFFER_SIZE, function(err, bytes2) {
           self2.bytesBuffer = bytes2;
           self2.bytesBufferIndex = 0;
           self2.isGeneratingBytes = false;
         });
       }
       if (this.bytesBufferIndex == -1) {
-        return crypto.randomBytes(bytes);
+        return crypto2.randomBytes(bytes);
       }
     }
     var result = this.bytesBuffer.slice(bytes * this.bytesBufferIndex, bytes * (this.bytesBufferIndex + 1));
@@ -179539,7 +179539,7 @@ var require_base64id = __commonJS((exports, module) => {
     }
     this.sequenceNumber = this.sequenceNumber + 1 | 0;
     rand.writeInt32BE(this.sequenceNumber, 11);
-    if (crypto.randomBytes) {
+    if (crypto2.randomBytes) {
       this.getRandomBytes(12).copy(rand);
     } else {
       [0, 4, 8].forEach(function(i5) {
@@ -231030,15 +231030,11 @@ var SiteConfigSchema = exports_external.object({
   outputDirectory: exports_external.string().optional(),
   installCommand: exports_external.string().optional()
 });
-var VisibilitySchema = exports_external.enum(["public", "private"], {
-  error: 'Invalid visibility value. Allowed values: "public", "private"'
-});
 var ProjectConfigSchema = exports_external.object({
   name: exports_external.string({
     error: "App name cannot be empty"
   }).min(1, "App name cannot be empty"),
   description: exports_external.string().optional(),
-  visibility: VisibilitySchema.optional(),
   site: SiteConfigSchema.optional(),
   entitiesDir: exports_external.string().optional().default("entities"),
   functionsDir: exports_external.string().optional().default("functions"),
@@ -239376,7 +239372,7 @@ async function createProject(projectName, description) {
         name: projectName,
         user_description: description ?? `Backend for '${projectName}'`,
         is_managed_source_code: false,
-        public_settings: "private_with_login"
+        public_settings: "public_without_login"
       }
     });
   } catch (error48) {
@@ -239390,22 +239386,6 @@ async function createProject(projectName, description) {
     projectId: result.data.id
   };
 }
-var VISIBILITY_TO_PUBLIC_SETTINGS = {
-  public: "public_without_login",
-  private: "private_with_login"
-};
-async function updateProjectVisibility(visibility) {
-  const { id } = getAppConfig();
-  try {
-    await base44Client.put(`api/apps/${id}`, {
-      json: {
-        public_settings: VISIBILITY_TO_PUBLIC_SETTINGS[visibility]
-      }
-    });
-  } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "updating project visibility");
-  }
-}
 async function listProjects() {
   let response;
   try {
@@ -239735,9 +239715,6 @@ async function deployAll(projectData, options) {
   });
   await agentResource.push(agents);
   const { results: connectorResults } = await pushConnectors(connectors);
-  if (project.visibility) {
-    await updateProjectVisibility(project.visibility);
-  }
   if (project.site?.outputDirectory) {
     const outputDir = resolve(project.root, project.site.outputDirectory);
     const { appUrl } = await deploySite(outputDir);
@@ -248949,7 +248926,7 @@ function getTypesCommand() {
 // src/cli/dev/dev-server/main.ts
 import { dirname as dirname14, join as join20 } from "node:path";
 var import_cors = __toESM(require_lib4(), 1);
-var import_express4 = __toESM(require_express(), 1);
+var import_express5 = __toESM(require_express(), 1);
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -249300,7 +249277,56 @@ function createFunctionRouter(manager, logger) {
 // src/cli/dev/dev-server/db/database.ts
 var import_nedb = __toESM(require_nedb(), 1);
 
+// ../../node_modules/nanoid/index.js
+import { webcrypto as crypto } from "node:crypto";
+
+// ../../node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/nanoid/index.js
+var POOL_SIZE_MULTIPLIER = 128;
+var pool;
+var poolOffset;
+function fillPool(bytes) {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto.getRandomValues(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+}
+function nanoid3(size = 21) {
+  fillPool(size |= 0);
+  let id2 = "";
+  for (let i5 = poolOffset - size;i5 < poolOffset; i5++) {
+    id2 += urlAlphabet[pool[i5] & 63];
+  }
+  return id2;
+}
+
+// src/cli/dev/dev-server/utils.ts
+function stripInternalFields(doc2) {
+  if (Array.isArray(doc2)) {
+    return doc2.map((d5) => stripInternalFields(d5));
+  }
+  const { _id, ...rest } = doc2;
+  return rest;
+}
+var getNowISOTimestamp = () => {
+  return new Date().toISOString().replace("Z", "000");
+};
+
 // src/cli/dev/dev-server/db/validator.ts
+class EntityValidationError extends Error {
+  context;
+  constructor(context) {
+    super(context.message);
+    this.context = context;
+  }
+}
 var fieldTypes = [
   "string",
   "integer",
@@ -249336,16 +249362,13 @@ class Validator {
     if (!partial2) {
       const requiredFieldsResponse = this.validateRequiredFields(record2, entitySchema);
       if (requiredFieldsResponse.hasError) {
-        return requiredFieldsResponse;
+        throw new EntityValidationError(requiredFieldsResponse.error);
       }
     }
     const fieldTypesResponse = this.validateFieldTypes(record2, entitySchema);
     if (fieldTypesResponse.hasError) {
-      return fieldTypesResponse;
+      throw new EntityValidationError(fieldTypesResponse.error);
     }
-    return {
-      hasError: false
-    };
   }
   createValidationError(message) {
     return {
@@ -249446,18 +249469,67 @@ class Validator {
 }
 
 // src/cli/dev/dev-server/db/database.ts
+var USER_COLLECTION = "user";
+
 class Database {
   collections = new Map;
   schemas = new Map;
   validator = new Validator;
-  load(entities) {
+  async load(entities) {
+    await this.loadUserCollection(entities);
     for (const entity2 of entities) {
-      this.collections.set(entity2.name, new import_nedb.default);
-      this.schemas.set(entity2.name, entity2);
+      const entityName = this.normalizeName(entity2.name);
+      if (entityName === USER_COLLECTION) {
+        continue;
+      }
+      this.collections.set(entityName, new import_nedb.default);
+      this.schemas.set(entityName, entity2);
     }
   }
+  async loadUserCollection(entities) {
+    const userEntity = entities.find((e8) => this.normalizeName(e8.name) === USER_COLLECTION);
+    this.schemas.set(USER_COLLECTION, this.buildUserSchema(userEntity));
+    const collection = new import_nedb.default;
+    this.collections.set(USER_COLLECTION, collection);
+    const userInfo = await readAuth();
+    const now = getNowISOTimestamp();
+    await collection.insertAsync({
+      id: nanoid3(),
+      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
+    });
+  }
+  buildUserSchema(customUserEntity) {
+    const builtInFields = {
+      full_name: { type: "string" },
+      email: { type: "string" }
+    };
+    if (!customUserEntity) {
+      return {
+        name: "User",
+        type: "object",
+        properties: { ...builtInFields, role: { type: "string" } }
+      };
+    }
+    for (const field of Object.keys(builtInFields)) {
+      if (field in customUserEntity.properties) {
+        throw new Error(`Error syncing entities: Invalid User schema: User schema cannot contain base fields: ${field}. These fields are built-in and managed by the system.`);
+      }
+    }
+    return {
+      ...customUserEntity,
+      properties: { ...customUserEntity.properties, ...builtInFields }
+    };
+  }
   getCollection(name2) {
-    return this.collections.get(name2);
+    return this.collections.get(this.normalizeName(name2));
   }
   getCollectionNames() {
     return Array.from(this.collections.keys());
@@ -249470,14 +249542,14 @@ class Database {
     this.schemas.clear();
   }
   validate(entityName, record2, partial2 = false) {
-    const schema9 = this.schemas.get(entityName);
+    const schema9 = this.schemas.get(this.normalizeName(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);
+    const schema9 = this.schemas.get(this.normalizeName(entityName));
     if (!schema9) {
       throw new Error(`Entity "${entityName}" not found`);
     }
@@ -249487,6 +249559,9 @@ class Database {
     }
     return this.validator.applyDefaults(filteredRecord, schema9);
   }
+  normalizeName(entityName) {
+    return entityName.toLowerCase();
+  }
 }
 
 // ../../node_modules/socket.io/wrapper.mjs
@@ -249521,40 +249596,105 @@ function broadcastEntityEvent(io6, appId, entityName, event) {
   });
 }
 
-// src/cli/dev/dev-server/routes/entities.ts
-var import_express2 = __toESM(require_express(), 1);
-
-// ../../node_modules/nanoid/index.js
-import { webcrypto as crypto } from "node:crypto";
-
-// ../../node_modules/nanoid/url-alphabet/index.js
-var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+// src/cli/dev/dev-server/routes/entities/entities-router.ts
+var import_express3 = __toESM(require_express(), 1);
 
-// ../../node_modules/nanoid/index.js
-var POOL_SIZE_MULTIPLIER = 128;
-var pool;
-var poolOffset;
-function fillPool(bytes) {
-  if (!pool || pool.length < bytes) {
-    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
-    crypto.getRandomValues(pool);
-    poolOffset = 0;
-  } else if (poolOffset + bytes > pool.length) {
-    crypto.getRandomValues(pool);
-    poolOffset = 0;
-  }
-  poolOffset += bytes;
-}
-function nanoid3(size = 21) {
-  fillPool(size |= 0);
-  let id2 = "";
-  for (let i5 = poolOffset - size;i5 < poolOffset; i5++) {
-    id2 += urlAlphabet[pool[i5] & 63];
-  }
-  return id2;
+// src/cli/dev/dev-server/routes/entities/entities-user-router.ts
+var import_express2 = __toESM(require_express(), 1);
+function createUserRouter(db2, logger) {
+  const router = import_express2.Router({ mergeParams: true });
+  const parseBody = import_express2.json();
+  router.use((req, res, next) => {
+    const auth2 = req.headers.authorization;
+    if (!auth2 || !auth2.startsWith("Bearer ")) {
+      res.status(401).json({ error: "Unauthorized" });
+      return;
+    }
+    next();
+  });
+  router.get("/:id", async (req, res) => {
+    let result;
+    if (req.params.id === "me") {
+      const userInfo = await readAuth();
+      result = await db2.getCollection(USER_COLLECTION)?.findOneAsync({ email: userInfo.email });
+    } else {
+      result = await db2.getCollection(USER_COLLECTION)?.findOneAsync({ id: req.params.id });
+    }
+    if (!result) {
+      res.status(404).json({ error: `User with id "${req.params.id}" not found` });
+      return;
+    }
+    res.json(stripInternalFields(result));
+  });
+  router.post("/", parseBody, async (req, res) => {
+    const userInfo = await readAuth();
+    const currentUser = await db2.getCollection(USER_COLLECTION)?.findOneAsync({ email: userInfo.email });
+    if (currentUser) {
+      const now = getNowISOTimestamp();
+      res.json({
+        created_by: userInfo.email,
+        created_by_id: currentUser.id,
+        id: nanoid3(),
+        created_date: now,
+        updated_date: now,
+        is_sample: false,
+        ...req.body
+      });
+    } else {
+      res.status(404).json({ error: "Unable to read data for the current user" });
+    }
+  });
+  router.post("/bulk", async (_req, res) => {
+    res.json({});
+  });
+  router.put("/:id", parseBody, async (req, res) => {
+    const restrictedFields = ["full_name", "email", "role"];
+    const collection = db2.getCollection(USER_COLLECTION);
+    const userInfo = await readAuth();
+    const userRecord = req.params.id === "me" ? await collection?.findOneAsync({
+      email: userInfo.email
+    }) : await collection?.findOneAsync({
+      id: req.params.id
+    });
+    if (userRecord) {
+      try {
+        const { id: _id, created_date: _created_date, ...body } = req.body;
+        const filteredBody = db2.prepareRecord(USER_COLLECTION, body, true);
+        const allowedFields = {};
+        for (const [key2, property] of Object.entries(filteredBody)) {
+          if (!restrictedFields.includes(key2)) {
+            allowedFields[key2] = property;
+          }
+        }
+        db2.validate(USER_COLLECTION, allowedFields, true);
+        const updateData = {
+          ...allowedFields,
+          updated_date: new Date().toISOString()
+        };
+        const updResult = await collection?.updateAsync({ id: userRecord.id }, { $set: updateData }, { returnUpdatedDocs: true });
+        if (!updResult?.affectedDocuments) {
+          throw new Error(`Failed to update user`);
+        }
+        res.json(stripInternalFields(updResult.affectedDocuments));
+      } catch (error48) {
+        if (error48 instanceof EntityValidationError) {
+          res.status(422).json(error48.context);
+          return;
+        }
+        logger.error(`Error in PUT /${USER_COLLECTION}/${req.params.id}:`, error48);
+        res.status(500).json({ error: "Internal server error" });
+      }
+    } else {
+      res.status(404).json({ error: `User record not found` });
+    }
+  });
+  router.delete("/:id", async (_req, res) => {
+    res.json({});
+  });
+  return router;
 }
 
-// src/cli/dev/dev-server/routes/entities.ts
+// src/cli/dev/dev-server/routes/entities/entities-router.ts
 function parseSort(sort) {
   if (!sort) {
     return;
@@ -249577,16 +249717,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);
@@ -249612,11 +249745,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 = createUserRouter(db2, logger);
+  router.use("/User", userRouter);
   router.get("/:entityName/:id", withCollection(async (req, res, collection) => {
     const { entityName, id: id2 } = req.params;
     try {
@@ -249678,11 +249808,7 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
       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;
-      }
+      db2.validate(entityName, filteredBody);
       const record2 = {
         ...filteredBody,
         id: nanoid3(),
@@ -249693,6 +249819,10 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
+      if (error48 instanceof EntityValidationError) {
+        res.status(422).json(error48.context);
+        return;
+      }
       logger.error(`Error in POST /${entityName}:`, error48);
       res.status(500).json({ error: "Internal server error" });
     }
@@ -249708,11 +249838,7 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
       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;
-        }
+        db2.validate(entityName, filteredRecord);
         records.push({
           ...filteredRecord,
           id: nanoid3(),
@@ -249724,6 +249850,10 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
     } catch (error48) {
+      if (error48 instanceof EntityValidationError) {
+        res.status(422).json(error48.context);
+        return;
+      }
       logger.error(`Error in POST /${entityName}/bulk:`, error48);
       res.status(500).json({ error: "Internal server error" });
     }
@@ -249733,11 +249863,7 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
     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;
-      }
+      db2.validate(entityName, filteredBody, true);
       const updateData = {
         ...filteredBody,
         updated_date: new Date().toISOString()
@@ -249751,6 +249877,10 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
       emit(appId, entityName, "update", updated);
       res.json(updated);
     } catch (error48) {
+      if (error48 instanceof EntityValidationError) {
+        res.status(422).json(error48.context);
+        return;
+      }
       logger.error(`Error in PUT /${entityName}/${id2}:`, error48);
       res.status(500).json({ error: "Internal server error" });
     }
@@ -249788,7 +249918,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";
@@ -249797,8 +249927,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 });
@@ -249868,7 +249998,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;
@@ -251581,7 +251711,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_express5.default();
   const remoteProxy = import_http_proxy_middleware2.createProxyMiddleware({
     target: BASE44_APP_URL,
     changeOrigin: true
@@ -251606,12 +251736,12 @@ async function createDevServer(options8) {
     R2.info(`Loaded functions: ${functionManager.getFunctionNames().join(", ")}`);
   }
   const db2 = new Database;
-  db2.load(entities);
+  await db2.load(entities);
   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) => {
@@ -251632,7 +251762,7 @@ async function createDevServer(options8) {
     }
     next();
   });
-  app.use("/media", import_express4.default.static(mediaFilesDir));
+  app.use("/media", import_express5.default.static(mediaFilesDir));
   const integrationRoutes = createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, devLogger);
   app.use("/api/apps/:appId/integration-endpoints", integrationRoutes);
   const customIntegrationRoutes = createCustomIntegrationRoutes(remoteProxy, devLogger);
@@ -251681,7 +251811,7 @@ async function createDevServer(options8) {
         if (previousEntityCount > 0) {
           devLogger.log("Entities directory changed, clearing data...");
         }
-        db2.load(entities2);
+        await db2.load(entities2);
         if (db2.getCollectionNames().length > 0) {
           devLogger.log(`Loaded entities: ${db2.getCollectionNames().join(", ")}`);
         }
@@ -256183,4 +256313,4 @@ export {
   CLIExitError
 };
 
-//# debugId=1A07E0BD1CCB37CD64756E2164756E21
+//# debugId=57B9E512088F387964756E2164756E21