@elevasis/core 0.1.0 → 0.2.0

package/src/platform/registry/resource-registry.ts

@@ -143,6 +143,85 @@ export class ResourceRegistry {
     }
   }
 
+  /**
+   * Get the remote resource IDs currently registered for an organization.
+   * Used to validate redeployments against the post-swap state before any
+   * live registry mutation occurs.
+   */
+  private getRemoteResourceIds(orgName: string): Set<string> {
+    const prefix = `${orgName}/`
+    const remoteIds = new Set<string>()
+    for (const key of this.remoteResources.keys()) {
+      if (key.startsWith(prefix)) {
+        remoteIds.add(key.slice(prefix.length))
+      }
+    }
+    return remoteIds
+  }
+
+  /**
+   * Build the "static + surviving" baseline for registration validation.
+   * On redeploy, this strips the currently remote-owned resources and
+   * deployment-owned metadata so validation reflects the state after swap.
+   */
+  private buildRegistrationBase(orgName: string): DeploymentSpec | undefined {
+    const existingOrg = this.registry[orgName]
+    if (!existingOrg) return undefined
+
+    const remoteIds = this.getRemoteResourceIds(orgName)
+    if (remoteIds.size === 0) return existingOrg
+
+    const relationships = existingOrg.relationships
+      ? Object.fromEntries(Object.entries(existingOrg.relationships).filter(([resourceId]) => !remoteIds.has(resourceId)))
+      : undefined
+
+    return {
+      ...existingOrg,
+      version: existingOrg.version ?? '0.0.0',
+      workflows: (existingOrg.workflows ?? []).filter((w) => !remoteIds.has(w.config.resourceId)),
+      agents: (existingOrg.agents ?? []).filter((a) => !remoteIds.has(a.config.resourceId)),
+      triggers: undefined,
+      integrations: undefined,
+      humanCheckpoints: undefined,
+      externalResources: undefined,
+      relationships: relationships && Object.keys(relationships).length > 0 ? relationships : undefined
+    }
+  }
+
+  /**
+   * Validate the registry state that would exist after registration succeeds.
+   * This runs before any live mutation so invalid redeploys preserve the
+   * currently active remote resources.
+   */
+  private validateRegistrationCandidate(orgName: string, incoming: DeploymentSpec): void {
+    const base = this.buildRegistrationBase(orgName)
+
+    const candidate: DeploymentSpec = base
+      ? {
+          ...base,
+          version: incoming.version ?? base.version ?? '0.0.0',
+          workflows: [...(base.workflows ?? []), ...(incoming.workflows ?? [])],
+          agents: [...(base.agents ?? []), ...(incoming.agents ?? [])],
+          triggers: incoming.triggers,
+          integrations: incoming.integrations,
+          humanCheckpoints: incoming.humanCheckpoints,
+          externalResources: incoming.externalResources,
+          relationships: incoming.relationships
+            ? {
+                ...(base.relationships ?? {}),
+                ...incoming.relationships
+              }
+            : base.relationships
+        }
+      : {
+          ...incoming,
+          version: incoming.version ?? '0.0.0'
+        }
+
+    validateDeploymentSpec(orgName, candidate)
+    validateRelationships(orgName, candidate)
+  }
+
   /**
    * Get a resource definition by ID
    * Returns full definition (WorkflowDefinition or AgentDefinition)
@@ -281,16 +360,13 @@ export class ResourceRegistry {
       }
     }
 
-    // If redeploying (some resources already registered as remote for this org), clean up first
-    if (this.isRemote(orgName)) {
-      this.unregisterOrganization(orgName)
-    }
-
-    // Check for conflicts with static (non-remote) resources in the existing org
-    const existingOrg = this.registry[orgName]
-    if (existingOrg) {
-      const staticWorkflowIds = new Set((existingOrg.workflows ?? []).map((w) => w.config.resourceId))
-      const staticAgentIds = new Set((existingOrg.agents ?? []).map((a) => a.config.resourceId))
+    // Check for conflicts against the static/surviving org state.
+    // On redeploy, current remote resources are excluded so a deployment can
+    // legitimately replace its own resource IDs without colliding with itself.
+    const validationBase = this.buildRegistrationBase(orgName)
+    if (validationBase) {
+      const staticWorkflowIds = new Set((validationBase.workflows ?? []).map((w) => w.config.resourceId))
+      const staticAgentIds = new Set((validationBase.agents ?? []).map((a) => a.config.resourceId))
 
       for (const id of incomingIds) {
         if (staticWorkflowIds.has(id) || staticAgentIds.has(id)) {
@@ -301,7 +377,19 @@ export class ResourceRegistry {
       }
     }
 
+    // Validate the merged deployment shape before mutating the live registry.
+    // This keeps the current deployment intact if a redeploy introduces
+    // invalid relationships or other registry-level validation failures.
+    this.validateRegistrationCandidate(orgName, org)
+
+    // If redeploying (some resources already registered as remote for this org), clean up only
+    // after validation succeeds so a failed redeploy preserves the current remote resources.
+    if (this.isRemote(orgName)) {
+      this.unregisterOrganization(orgName)
+    }
+
     // Merge incoming resources into the org (or create new org entry)
+    const existingOrg = this.registry[orgName]
     if (existingOrg) {
       existingOrg.workflows = [...(existingOrg.workflows ?? []), ...(org.workflows ?? [])]
       existingOrg.agents = [...(existingOrg.agents ?? []), ...(org.agents ?? [])]

package/src/projects/api-schemas.ts

@@ -101,7 +101,8 @@ export const UpdateProjectRequestSchema = z
 
 export const GetProjectsQuerySchema = z
   .object({
-    kind: ProjectKindSchema.optional()
+    kind: ProjectKindSchema.optional(),
+    status: ProjectStatusSchema.optional()
   })
   .strict()