@base44-preview/cli 0.0.51-pr.503.770ecd5 → 0.0.51-pr.503.89e310a

package/dist/cli/index.js

@@ -234623,7 +234623,7 @@ var SiteConfigSchema = exports_external.object({
   installCommand: exports_external.string().optional()
 });
 var PluginMetadataSchema = exports_external.object({
-  id: exports_external.string().min(1, "Plugin id cannot be empty").regex(/^[a-zA-Z0-9_-]+$/, "Plugin id can only contain letters, numbers, underscores, and dashes")
+  namespace: exports_external.string().min(1, "Plugin namespace cannot be empty").regex(/^[a-zA-Z0-9_-]+$/, "Plugin namespace can only contain letters, numbers, underscores, and dashes")
 });
 var PluginReferenceSchema = exports_external.object({
   source: exports_external.string().min(1, "Plugin source cannot be empty")
@@ -241599,28 +241599,28 @@ function resolvePluginRoot(pluginSource, fromRoot) {
   const req = createRequire2(join3(fromRoot, "package.json"));
   return dirname3(req.resolve(`${pluginSource}/package.json`));
 }
-function requirePluginId(project, pluginSource, configPath) {
-  if (!project.plugin?.id) {
-    throw new ConfigInvalidError(`Plugin loaded from "${pluginSource}" must define plugin.id`, configPath);
+function requirePluginNamespace(project, pluginSource, configPath) {
+  if (!project.plugin?.namespace) {
+    throw new ConfigInvalidError(`Plugin loaded from "${pluginSource}" must define plugin.namespace`, configPath);
   }
-  return project.plugin.id;
+  return project.plugin.namespace;
 }
-function namespacePluginFunctions(functions, pluginId) {
+function namespacePluginFunctions(functions, pluginNamespace) {
   return functions.map((fn) => ({
     ...fn,
-    name: `${pluginId}__${fn.name}`,
+    name: `${pluginNamespace}__${fn.name}`,
     source: {
       type: "plugin",
-      id: pluginId
+      namespace: pluginNamespace
     }
   }));
 }
-function markPluginEntities(entities, pluginId) {
+function markPluginEntities(entities, pluginNamespace) {
   return entities.map((entity) => ({
     ...entity,
     source: {
       type: "plugin",
-      id: pluginId
+      namespace: pluginNamespace
     }
   }));
 }
@@ -242782,7 +242782,7 @@ var ResourceSourceSchema = exports_external.discriminatedUnion("type", [
   }),
   exports_external.object({
     type: exports_external.literal("plugin"),
-    id: exports_external.string().min(1, "Plugin id cannot be empty")
+    namespace: exports_external.string().min(1, "Plugin namespace cannot be empty")
   })
 ]);
 
@@ -243464,7 +243464,7 @@ async function findProjectRoot(startPath) {
 }
 
 class ProjectConfigReader {
-  pluginIds = new Set;
+  pluginNamespaces = new Set;
   async readProjectConfig(projectRoot) {
     const { root, configPath } = await this.findConfigOrThrow(projectRoot);
     const project = await this.readConfigFile(configPath);
@@ -243522,31 +243522,31 @@ class ProjectConfigReader {
       throw new ConfigInvalidError("Plugin projects cannot define plugins in this version.", configPath);
     }
   }
-  registerPluginId(pluginId, configPath) {
-    if (this.pluginIds.has(pluginId)) {
-      throw new ConfigInvalidError(`Duplicate plugin id "${pluginId}" in project configuration`, configPath, {
+  registerPluginNamespace(pluginNamespace, configPath) {
+    if (this.pluginNamespaces.has(pluginNamespace)) {
+      throw new ConfigInvalidError(`Duplicate plugin namespace "${pluginNamespace}" in project configuration`, configPath, {
         hints: [
           {
-            message: "Remove the plugin or change plugin id"
+            message: "Remove the plugin or change plugin namespace"
           }
         ]
       });
     }
-    this.pluginIds.add(pluginId);
+    this.pluginNamespaces.add(pluginNamespace);
   }
   async readPluginConfig(plugin, hostRoot) {
     const pluginRoot = resolvePluginRoot(plugin.source, hostRoot);
     const { configPath } = await this.findConfigOrThrow(pluginRoot);
     const project = await this.readConfigFile(configPath);
-    const pluginId = requirePluginId(project, plugin.source, configPath);
+    const pluginNamespace = requirePluginNamespace(project, plugin.source, configPath);
     this.assertPluginProjectDoesNotLoadPlugins(project, configPath);
-    return { configPath, pluginId, project };
+    return { configPath, pluginNamespace, project };
   }
-  async readPluginResources(project, configPath, pluginId) {
+  async readPluginResources(project, configPath, pluginNamespace) {
     const resources = await this.readProjectResources(configPath, project);
     return {
-      entities: markPluginEntities(resources.entities, pluginId),
-      functions: namespacePluginFunctions(resources.functions, pluginId),
+      entities: markPluginEntities(resources.entities, pluginNamespace),
+      functions: namespacePluginFunctions(resources.functions, pluginNamespace),
       agents: [],
       connectors: [],
       authConfig: []
@@ -243555,15 +243555,15 @@ class ProjectConfigReader {
   async readPlugins(plugins, projectRoot) {
     const entities = [];
     const functions = [];
-    const entityNameByPluginId = new Map;
+    const entityNameByPluginNamespace = new Map;
     for (const plugin of plugins) {
-      const { configPath, pluginId, project } = await this.readPluginConfig(plugin, projectRoot);
-      this.registerPluginId(pluginId, configPath);
-      const pluginData = await this.readPluginResources(project, configPath, pluginId);
+      const { configPath, pluginNamespace, project } = await this.readPluginConfig(plugin, projectRoot);
+      this.registerPluginNamespace(pluginNamespace, configPath);
+      const pluginData = await this.readPluginResources(project, configPath, pluginNamespace);
       for (const entity of pluginData.entities) {
-        const existingPluginId = entityNameByPluginId.get(entity.name);
-        if (existingPluginId) {
-          throw new ConfigInvalidError(`Entity "${entity.name}" is defined by more than one plugin: "${existingPluginId}" and "${pluginId}".`, configPath, {
+        const existingPluginNamespace = entityNameByPluginNamespace.get(entity.name);
+        if (existingPluginNamespace) {
+          throw new ConfigInvalidError(`Entity "${entity.name}" is defined by more than one plugin: "${existingPluginNamespace}" and "${pluginNamespace}".`, configPath, {
             hints: [
               {
                 message: "Plugin entity names are not namespaced. Remove one plugin or rename one of the entities."
@@ -243571,7 +243571,7 @@ class ProjectConfigReader {
             ]
           });
         }
-        entityNameByPluginId.set(entity.name, pluginId);
+        entityNameByPluginNamespace.set(entity.name, pluginNamespace);
       }
       entities.push(...pluginData.entities);
       functions.push(...pluginData.functions);
@@ -261525,4 +261525,4 @@ export {
   CLIExitError
 };
 
-//# debugId=6F53421EFB4CBB2764756E2164756E21
+//# debugId=90CED69C719B38A364756E2164756E21