@base44-preview/cli 0.0.51-pr.503.3e3774c → 0.0.51-pr.503.6669b14

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({
@@ -241591,9 +241591,9 @@ 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"));
@@ -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)."
@@ -243444,6 +243441,9 @@ var functionResource = {
   push: (functions) => deployFunctionsSequentially(functions)
 };
 // src/core/project/config.ts
+function describeFunctionSource(fn) {
+  return fn.source.type === "plugin" ? `plugin "${fn.source.namespace}"` : "project";
+}
 async function findConfigInDir(dir) {
   const files = await globby(PROJECT_CONFIG_PATTERNS, {
     cwd: dir,
@@ -243464,7 +243464,7 @@ async function findProjectRoot(startPath) {
 }
 
 class ProjectConfigReader {
-  pluginNamespaces = new Set;
+  pluginSourceByNamespace = new Map;
   async readProjectConfig(projectRoot) {
     const { root, configPath } = await this.findConfigOrThrow(projectRoot);
     const project = await this.readConfigFile(configPath);
@@ -243476,6 +243476,7 @@ class ProjectConfigReader {
       ...localResources.functions,
       ...pluginResources.functions
     ];
+    this.validateFunctionNames(functions, configPath);
     return {
       project: { ...project, root, configPath },
       entities,
@@ -243522,9 +243523,10 @@ class ProjectConfigReader {
       throw new ConfigInvalidError("Plugin projects cannot define plugins in this version.", configPath);
     }
   }
-  registerPluginNamespace(pluginNamespace, configPath) {
-    if (this.pluginNamespaces.has(pluginNamespace)) {
-      throw new ConfigInvalidError(`Duplicate plugin namespace "${pluginNamespace}" 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 namespace"
@@ -243532,21 +243534,21 @@ class ProjectConfigReader {
         ]
       });
     }
-    this.pluginNamespaces.add(pluginNamespace);
+    this.pluginSourceByNamespace.set(namespace, source);
   }
   async readPluginConfig(plugin, hostConfigPath) {
     const pluginRoot = resolvePluginRoot(plugin.source, dirname6(hostConfigPath));
     const { configPath } = await this.findConfigOrThrow(pluginRoot);
     const project = await this.readConfigFile(configPath);
-    const pluginNamespace = requirePluginNamespace(project, plugin.source, configPath);
+    const namespace = requirePluginNamespace(project, plugin.source, configPath);
     this.assertPluginProjectDoesNotLoadPlugins(project, configPath);
-    return { configPath, pluginNamespace, project };
+    return { configPath, namespace, project, source: plugin.source };
   }
-  async readPluginResources(project, configPath, pluginNamespace) {
+  async readPluginResources(project, configPath, namespace) {
     const resources = await this.readProjectResources(configPath, project);
     return {
-      entities: markPluginEntities(resources.entities, pluginNamespace),
-      functions: namespacePluginFunctions(resources.functions, pluginNamespace),
+      entities: markPluginEntities(resources.entities, namespace),
+      functions: namespacePluginFunctions(resources.functions, namespace),
       agents: [],
       connectors: [],
       authConfig: []
@@ -243555,19 +243557,20 @@ class ProjectConfigReader {
   async readPlugins(plugins, configPath) {
     const entities = [];
     const functions = [];
-    const entityNameByPluginNamespace = new Map;
+    const pluginSourceByEntityName = new Map;
     for (const plugin of plugins) {
       const {
         configPath: pluginConfigPath,
-        pluginNamespace,
-        project
+        namespace,
+        project,
+        source
       } = await this.readPluginConfig(plugin, configPath);
-      this.registerPluginNamespace(pluginNamespace, pluginConfigPath);
-      const pluginData = await this.readPluginResources(project, pluginConfigPath, pluginNamespace);
+      this.registerPluginNamespace(namespace, source, pluginConfigPath);
+      const pluginData = await this.readPluginResources(project, pluginConfigPath, namespace);
       for (const entity of pluginData.entities) {
-        const existingPluginNamespace = entityNameByPluginNamespace.get(entity.name);
-        if (existingPluginNamespace) {
-          throw new ConfigInvalidError(`Entity "${entity.name}" is defined by more than one plugin: "${existingPluginNamespace}" and "${pluginNamespace}".`, pluginConfigPath, {
+        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."
@@ -243575,7 +243578,7 @@ class ProjectConfigReader {
             ]
           });
         }
-        entityNameByPluginNamespace.set(entity.name, pluginNamespace);
+        pluginSourceByEntityName.set(entity.name, source);
       }
       entities.push(...pluginData.entities);
       functions.push(...pluginData.functions);
@@ -243588,6 +243591,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 (${describeFunctionSource(existingFunction)} and ${describeFunctionSource(fn)}).`, 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;
@@ -252803,12 +252822,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`
@@ -261529,4 +261548,4 @@ export {
   CLIExitError
 };
 
-//# debugId=F9698F6E012A29BB64756E2164756E21
+//# debugId=9FAEFFBF52D07E0464756E2164756E21