@base44-preview/cli 0.0.51-pr.503.abe7299 → 0.0.51-pr.503.f6edfc1

package/dist/cli/index.js

@@ -124338,7 +124338,7 @@ var init_prettier = __esm(() => {
         const absolute = [];
         const relative22 = [];
         for (const pattern of patterns) {
-          if (isAbsolute2(pattern)) {
+          if (isAbsolute3(pattern)) {
             absolute.push(pattern);
           } else {
             relative22.push(pattern);
@@ -124347,10 +124347,10 @@ var init_prettier = __esm(() => {
         return [absolute, relative22];
       }
       exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
-      function isAbsolute2(pattern) {
+      function isAbsolute3(pattern) {
         return path152.isAbsolute(pattern);
       }
-      exports.isAbsolute = isAbsolute2;
+      exports.isAbsolute = isAbsolute3;
     }
   });
   require_merge22 = __commonJS2({
@@ -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")
@@ -241591,36 +241591,36 @@ import { dirname as dirname6, join as join9 } from "node:path";
 
 // src/core/project/plugins.ts
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname3, join as join3, resolve } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join3, resolve } from "node:path";
 function resolvePluginRoot(pluginSource, fromRoot) {
-  if (pluginSource.startsWith(".")) {
+  if (pluginSource.startsWith(".") || isAbsolute2(pluginSource)) {
     return resolve(fromRoot, pluginSource);
   }
   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")
   })
 ]);
 
@@ -242943,7 +242943,7 @@ async function readAllEntities(entitiesDir) {
   const names = new Set;
   for (const entity of entities) {
     if (names.has(entity.name)) {
-      throw new InvalidInputError(`Duplicate entity name "${entity.name}"`, {
+      throw new ConfigInvalidError(`Duplicate entity name "${entity.name}" in ${entitiesDir}`, entitiesDir, {
         hints: [
           {
             message: `Remove duplicate entities with name "${entity.name}" - only one entity per name is allowed`
@@ -242969,11 +242969,8 @@ var entityResource = {
 };
 // src/core/resources/entity/merge.ts
 function mergePluginEntity(pluginEntity, projectEntity, configPath) {
-  const unsupportedFields = [
-    projectEntity.title ? "title" : null,
-    projectEntity.description ? "description" : null,
-    projectEntity.rls ? "rls" : null
-  ].filter(Boolean);
+  const projectEntityFields = new Set(Object.keys(projectEntity));
+  const unsupportedFields = ["title", "description", "rls"].filter((field) => projectEntityFields.has(field));
   if (unsupportedFields.length > 0) {
     throw new ConfigInvalidError(`Project entity "${projectEntity.name}" extends a plugin entity and cannot override fields: ${unsupportedFields.join(", ")}.`, configPath);
   }
@@ -242986,7 +242983,7 @@ function mergePluginEntity(pluginEntity, projectEntity, configPath) {
   }
   for (const requiredProperty of projectEntity.required ?? []) {
     if (!addedPropertyNames.has(requiredProperty)) {
-      throw new ConfigInvalidError(`Required property "${requiredProperty}" must be declared in project entity "${projectEntity.name}" properties`, configPath);
+      throw new ConfigInvalidError(`Project entity "${projectEntity.name}" can only mark project-added properties as required; "${requiredProperty}" is not declared in the project extension.`, configPath);
     }
   }
   const required2 = pluginEntity.required || projectEntity.required ? [
@@ -243297,7 +243294,7 @@ async function readAllFunctions(functionsDir) {
   const names = new Set;
   for (const fn of functions) {
     if (names.has(fn.name)) {
-      throw new InvalidInputError(`Duplicate function name "${fn.name}"`, {
+      throw new ConfigInvalidError(`Duplicate function name "${fn.name}" in ${functionsDir}`, functionsDir, {
         hints: [
           {
             message: "Ensure each function has a unique name (or path for zero-config functions)."
@@ -243464,18 +243461,19 @@ async function findProjectRoot(startPath) {
 }
 
 class ProjectConfigReader {
-  pluginIds = new Set;
+  pluginSourceByNamespace = new Map;
   async readProjectConfig(projectRoot) {
     const { root, configPath } = await this.findConfigOrThrow(projectRoot);
     const project = await this.readConfigFile(configPath);
     this.assertPluginProjectDoesNotLoadPlugins(project, configPath);
     const localResources = await this.readProjectResources(configPath, project);
-    const pluginResources = await this.readPlugins(project.plugins, root);
+    const pluginResources = await this.readPlugins(project.plugins, configPath);
     const entities = mergeProjectAndPluginEntities(localResources.entities, pluginResources.entities, configPath);
     const functions = [
       ...localResources.functions,
       ...pluginResources.functions
     ];
+    this.validateFunctionNames(functions, configPath);
     return {
       project: { ...project, root, configPath },
       entities,
@@ -243522,48 +243520,54 @@ 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(namespace, source, configPath) {
+    const existingSource = this.pluginSourceByNamespace.get(namespace);
+    if (existingSource) {
+      throw new ConfigInvalidError(`Duplicate plugin namespace "${namespace}" in project configuration: "${existingSource}" and "${source}".`, configPath, {
         hints: [
           {
-            message: "Remove the plugin or change plugin id"
+            message: "Remove the plugin or change plugin namespace"
           }
         ]
       });
     }
-    this.pluginIds.add(pluginId);
+    this.pluginSourceByNamespace.set(namespace, source);
   }
-  async readPluginConfig(plugin, hostRoot) {
-    const pluginRoot = resolvePluginRoot(plugin.source, hostRoot);
+  async readPluginConfig(plugin, hostConfigPath) {
+    const pluginRoot = resolvePluginRoot(plugin.source, dirname6(hostConfigPath));
     const { configPath } = await this.findConfigOrThrow(pluginRoot);
     const project = await this.readConfigFile(configPath);
-    const pluginId = requirePluginId(project, plugin.source, configPath);
+    const namespace = requirePluginNamespace(project, plugin.source, configPath);
     this.assertPluginProjectDoesNotLoadPlugins(project, configPath);
-    return { configPath, pluginId, project };
+    return { configPath, namespace, project, source: plugin.source };
   }
-  async readPluginResources(project, configPath, pluginId) {
+  async readPluginResources(project, configPath, namespace) {
     const resources = await this.readProjectResources(configPath, project);
     return {
-      entities: markPluginEntities(resources.entities, pluginId),
-      functions: namespacePluginFunctions(resources.functions, pluginId),
+      entities: markPluginEntities(resources.entities, namespace),
+      functions: namespacePluginFunctions(resources.functions, namespace),
       agents: [],
       connectors: [],
       authConfig: []
     };
   }
-  async readPlugins(plugins, projectRoot) {
+  async readPlugins(plugins, configPath) {
     const entities = [];
     const functions = [];
-    const entityNameByPluginId = new Map;
+    const pluginSourceByEntityName = 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: pluginConfigPath,
+        namespace,
+        project,
+        source
+      } = await this.readPluginConfig(plugin, configPath);
+      this.registerPluginNamespace(namespace, source, pluginConfigPath);
+      const pluginData = await this.readPluginResources(project, pluginConfigPath, namespace);
       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 existingSource = pluginSourceByEntityName.get(entity.name);
+        if (existingSource) {
+          throw new ConfigInvalidError(`Entity "${entity.name}" is defined by more than one plugin: "${existingSource}" and "${source}".`, pluginConfigPath, {
             hints: [
               {
                 message: "Plugin entity names are not namespaced. Remove one plugin or rename one of the entities."
@@ -243571,7 +243575,7 @@ class ProjectConfigReader {
             ]
           });
         }
-        entityNameByPluginId.set(entity.name, pluginId);
+        pluginSourceByEntityName.set(entity.name, source);
       }
       entities.push(...pluginData.entities);
       functions.push(...pluginData.functions);
@@ -243584,6 +243588,22 @@ class ProjectConfigReader {
       authConfig: []
     };
   }
+  validateFunctionNames(functions, configPath) {
+    const functionsByName = new Map;
+    for (const fn of functions) {
+      const existingFunction = functionsByName.get(fn.name);
+      if (existingFunction) {
+        throw new ConfigInvalidError(`Duplicate function name "${fn.name}" after loading project plugins.`, configPath, {
+          hints: [
+            {
+              message: "Rename the project function or change the plugin namespace/function name so every deploy name is unique."
+            }
+          ]
+        });
+      }
+      functionsByName.set(fn.name, fn);
+    }
+  }
 }
 async function readProjectConfig(projectRoot) {
   const reader = new ProjectConfigReader;
@@ -252799,12 +252819,12 @@ async function pullFunctionsAction({ log, runTask: runTask2 }, name2) {
     successMessage: "Functions fetched successfully",
     errorMessage: "Failed to fetch functions"
   });
-  const matchingRemote = name2 ? remoteFunctions.filter((f) => f.name === name2) : remoteFunctions;
   if (name2 && pluginFunctionNames.has(name2)) {
     return {
       outroMessage: `Function "${name2}" is managed by a plugin and was not pulled into ${functionsDir}`
     };
   }
+  const matchingRemote = name2 ? remoteFunctions.filter((f) => f.name === name2) : remoteFunctions;
   if (name2 && matchingRemote.length === 0) {
     return {
       outroMessage: `Function "${name2}" not found on remote`
@@ -261525,4 +261545,4 @@ export {
   CLIExitError
 };
 
-//# debugId=6F53421EFB4CBB2764756E2164756E21
+//# debugId=2ADA1E4C26BBE1A464756E2164756E21