@replit/river 0.23.8 → 0.23.10

package/dist/{chunk-WQRQFAP6.js → chunk-B323CECK.js}

@@ -6,7 +6,7 @@ import {
   getPropagationContext,
   isStreamClose,
   isStreamOpen
-} from "./chunk-ELZRZNA5.js";
+} from "./chunk-FRICSBDW.js";
 
 // router/services.ts
 import { Type } from "@sinclair/typebox";
@@ -210,6 +210,468 @@ var ServiceScaffold = class {
   }
 };
 
+// router/diff.ts
+function diffServerSchema(oldServer, newServer) {
+  const allServices = /* @__PURE__ */ new Set([
+    ...Object.keys(oldServer.services),
+    ...Object.keys(newServer.services)
+  ]);
+  const breakages = {};
+  for (const serviceName of allServices) {
+    const oldService = oldServer.services[serviceName];
+    const newService = newServer.services[serviceName];
+    const breakage = diffService(oldService, newService);
+    if (breakage) {
+      breakages[serviceName] = breakage;
+    }
+  }
+  if (Object.keys(breakages).length) {
+    return { serviceBreakages: breakages };
+  }
+  return null;
+}
+function diffService(oldService, newService) {
+  if (!newService) {
+    return { reason: "removed" };
+  }
+  if (!oldService) {
+    return null;
+  }
+  const allProcedures = /* @__PURE__ */ new Set([
+    ...Object.keys(oldService.procedures),
+    ...Object.keys(newService.procedures)
+  ]);
+  const breakages = {};
+  for (const procedureName of allProcedures) {
+    const aProcedure = oldService.procedures[procedureName];
+    const bProcedure = newService.procedures[procedureName];
+    const breakage = diffProcedure(aProcedure, bProcedure);
+    if (breakage) {
+      breakages[procedureName] = breakage;
+    }
+  }
+  if (Object.keys(breakages).length) {
+    return { reason: "modified", procedureBreakages: breakages };
+  }
+  return null;
+}
+function diffProcedure(oldProcedure, newProcedure) {
+  if (!newProcedure) {
+    return { reason: "removed" };
+  }
+  if (!oldProcedure) {
+    return null;
+  }
+  if (oldProcedure.type !== newProcedure.type) {
+    return {
+      reason: "type-changed",
+      oldType: oldProcedure.type,
+      newType: newProcedure.type
+    };
+  }
+  const inputBreakage = diffProcedureField(
+    oldProcedure.input,
+    newProcedure.input,
+    "client"
+  );
+  const initBreakage = diffProcedureField(
+    oldProcedure.init,
+    newProcedure.init,
+    "client"
+  );
+  const outputBreakage = diffProcedureField(
+    oldProcedure.output,
+    newProcedure.output,
+    "server"
+  );
+  if (inputBreakage ?? initBreakage ?? outputBreakage) {
+    const result = {
+      reason: "modified"
+    };
+    if (inputBreakage) {
+      result.input = inputBreakage;
+    }
+    if (initBreakage) {
+      result.init = initBreakage;
+    }
+    if (outputBreakage) {
+      result.output = outputBreakage;
+    }
+    return result;
+  }
+  return null;
+}
+function diffProcedureField(oldSchema, newSchema, origin) {
+  if (!oldSchema && !newSchema) {
+    return null;
+  }
+  const diffBreakage = diffRequired(oldSchema, newSchema, origin, false, false);
+  if (diffBreakage) {
+    return diffBreakage;
+  }
+  if (!oldSchema || !newSchema) {
+    throw new Error("Appease typescript, this should never happen");
+  }
+  return diffJSONSchema(oldSchema, newSchema, origin);
+}
+function diffRequired(oldSchema, newSchema, origin, oldRequired, newRequired) {
+  if (!newSchema && !oldSchema) {
+    throw new Error("Both old and new schema are undefined");
+  }
+  if (!newSchema) {
+    if (!oldRequired && origin == "server") {
+      return null;
+    }
+    return { reason: "removed-required" };
+  }
+  if (!oldSchema) {
+    if (newRequired && origin === "client") {
+      return { reason: "new-required" };
+    }
+    return null;
+  }
+  if (origin === "client" && !oldRequired && newRequired) {
+    return { reason: "new-required" };
+  }
+  if (origin === "server" && oldRequired && !newRequired) {
+    return { reason: "removed-required" };
+  }
+  return null;
+}
+function diffJSONSchema(oldSchema, newSchema, origin) {
+  if (oldSchema.type !== newSchema.type) {
+    return {
+      reason: "type-changed",
+      oldType: getReportingType(oldSchema),
+      newType: getReportingType(newSchema)
+    };
+  }
+  if (getReportingType(oldSchema) !== getReportingType(newSchema)) {
+    return {
+      reason: "type-changed",
+      oldType: getReportingType(oldSchema),
+      newType: getReportingType(newSchema)
+    };
+  }
+  if ("const" in oldSchema && "const" in newSchema && oldSchema.const !== newSchema.const) {
+    return {
+      reason: "type-changed",
+      oldType: `${getReportingType(oldSchema)}-const-${oldSchema.const}`,
+      newType: `${getReportingType(newSchema)}-const-${newSchema.const}`
+    };
+  }
+  if ("const" in oldSchema && !("const" in newSchema) && origin === "server") {
+    return {
+      reason: "type-changed",
+      oldType: `${getReportingType(oldSchema)}-const-${oldSchema.const}`,
+      newType: getReportingType(newSchema)
+    };
+  }
+  if ("const" in newSchema && !("const" in oldSchema) && origin === "client") {
+    return {
+      reason: "type-changed",
+      oldType: getReportingType(oldSchema),
+      newType: `${getReportingType(newSchema)}-const-${newSchema.const}`
+    };
+  }
+  const breakages = {};
+  if ("$ref" in newSchema) {
+    if (newSchema.$ref !== oldSchema.$ref) {
+      return {
+        reason: "type-changed",
+        oldType: getReportingType(oldSchema),
+        newType: getReportingType(newSchema)
+      };
+    }
+  } else if ("not" in newSchema) {
+    const notBreakage = diffJSONSchema(
+      oldSchema.not,
+      newSchema.not,
+      origin
+    );
+    if (notBreakage) {
+      breakages.not = notBreakage;
+    }
+  } else if ("anyOf" in newSchema) {
+    const oldAnyOfStringified = oldSchema.anyOf.map((el) => JSON.stringify(el)).sort();
+    const newAnyOfStringified = newSchema.anyOf.map((el) => JSON.stringify(el)).sort();
+    const anyOfBreakages = {};
+    for (let i = 0; i < oldAnyOfStringified.length; i++) {
+      if (newAnyOfStringified.includes(oldAnyOfStringified[i])) {
+        continue;
+      }
+      if (!newAnyOfStringified[i]) {
+        if (origin === "server") {
+          continue;
+        }
+        anyOfBreakages[`old-${i}`] = { reason: "removed-required" };
+      } else {
+        const breakage = diffJSONSchema(
+          JSON.parse(oldAnyOfStringified[i]),
+          JSON.parse(newAnyOfStringified[i]),
+          origin
+        );
+        if (breakage) {
+          anyOfBreakages[`old-${i}`] = breakage;
+        }
+      }
+    }
+    for (let i = 0; i < newAnyOfStringified.length; i++) {
+      if (oldAnyOfStringified.includes(newAnyOfStringified[i])) {
+        continue;
+      }
+      if (!oldAnyOfStringified[i]) {
+        if (origin === "client") {
+          continue;
+        }
+        anyOfBreakages[`new-${i}`] = { reason: "new-required" };
+      } else {
+        const breakage = diffJSONSchema(
+          JSON.parse(oldAnyOfStringified[i]),
+          JSON.parse(newAnyOfStringified[i]),
+          origin
+        );
+        if (breakage) {
+          anyOfBreakages[`new-${i}`] = breakage;
+        }
+      }
+    }
+    if (Object.keys(anyOfBreakages).length > 0) {
+      breakages.anyOf = {
+        reason: "field-breakage",
+        fieldBreakages: anyOfBreakages
+      };
+    }
+  } else if ("oneOf" in newSchema) {
+    throw new Error("oneOf is not supported, typebox does not emit it");
+  } else if ("allOf" in newSchema) {
+    if (newSchema.allOf.length !== oldSchema.allOf.length) {
+      breakages.allOf = {
+        reason: "type-changed",
+        oldType: `${oldSchema.allOf}`,
+        newType: `${newSchema.allOf}`
+      };
+    } else {
+      for (let i = 0; i < newSchema.allOf.length; i++) {
+        const breakage = diffJSONSchema(
+          oldSchema.allOf[i],
+          newSchema.allOf[i],
+          origin
+        );
+        if (breakage) {
+          breakages.allOf = breakage;
+          break;
+        }
+      }
+    }
+  } else if (newSchema.type === "array") {
+    const itemsBreakages = diffJSONSchema(
+      oldSchema.items,
+      newSchema.items,
+      origin
+    );
+    if (itemsBreakages) {
+      breakages.items = itemsBreakages;
+    }
+    if (oldSchema.minItems < newSchema.minItems) {
+      if (origin === "client") {
+        breakages.minItems = {
+          reason: "type-changed",
+          oldType: `${oldSchema.minItems}`,
+          newType: `${newSchema.minItems}`
+        };
+      }
+    } else if (oldSchema.minItems > newSchema.minItems) {
+      if (origin === "server") {
+        breakages.minItems = {
+          reason: "type-changed",
+          oldType: `${oldSchema.minItems}`,
+          newType: `${newSchema.minItems}`
+        };
+      }
+    }
+    if (oldSchema.maxItems < newSchema.maxItems) {
+      if (origin === "server") {
+        breakages.maxItems = {
+          reason: "type-changed",
+          oldType: `${oldSchema.maxItems}`,
+          newType: `${newSchema.maxItems}`
+        };
+      }
+    } else if (oldSchema.maxItems > newSchema.maxItems) {
+      if (origin === "client") {
+        breakages.maxItems = {
+          reason: "type-changed",
+          oldType: `${oldSchema.maxItems}`,
+          newType: `${newSchema.maxItems}`
+        };
+      }
+    }
+    if (!oldSchema.uniqueItems && newSchema.uniqueItems && origin === "client") {
+      breakages.uniqueItems = {
+        reason: "type-changed",
+        oldType: `${!!oldSchema.uniqueItems}`,
+        newType: `${!!newSchema.uniqueItems}`
+      };
+    }
+    if ("contains" in newSchema !== "contains" in oldSchema) {
+      if ("contains" in newSchema && !("contains" in oldSchema) && origin === "client") {
+        breakages.contains = {
+          reason: "type-changed",
+          oldType: "no-contains",
+          newType: "contains"
+        };
+      }
+    } else if ("contains" in newSchema) {
+      const containsBreakage = diffJSONSchema(
+        oldSchema.contains,
+        newSchema.contains,
+        origin
+      );
+      if (containsBreakage) {
+        breakages.contains = containsBreakage;
+      }
+    }
+    if (oldSchema.minContains < newSchema.minContains) {
+      if (origin === "client") {
+        breakages.minContains = {
+          reason: "type-changed",
+          oldType: `${oldSchema.minContains}`,
+          newType: `${newSchema.minContains}`
+        };
+      }
+    } else if (oldSchema.minContains > newSchema.minContains) {
+      if (origin === "server") {
+        breakages.minContains = {
+          reason: "type-changed",
+          oldType: `${oldSchema.minContains}`,
+          newType: `${newSchema.minContains}`
+        };
+      }
+    }
+    if (oldSchema.maxContains < newSchema.maxContains) {
+      if (origin === "server") {
+        breakages.maxContains = {
+          reason: "type-changed",
+          oldType: `${oldSchema.maxContains}`,
+          newType: `${newSchema.maxContains}`
+        };
+      }
+    } else if (oldSchema.maxContains > newSchema.maxContains) {
+      if (origin === "client") {
+        breakages.maxContains = {
+          reason: "type-changed",
+          oldType: `${oldSchema.maxContains}`,
+          newType: `${newSchema.maxContains}`
+        };
+      }
+    }
+  } else if (newSchema.type === "object") {
+    if ("properties" in newSchema !== "properties" in oldSchema) {
+      return {
+        reason: "type-changed",
+        oldType: "properties" in oldSchema ? "probably-object" : "probably-record",
+        newType: "properties" in newSchema ? "probably-object" : "probably-record"
+      };
+    }
+    if ("properties" in newSchema) {
+      const propertiesBreakages = diffObjectProperties(
+        oldSchema.properties,
+        newSchema.properties,
+        origin,
+        oldSchema.required,
+        newSchema.required
+      );
+      if (Object.keys(propertiesBreakages).length) {
+        breakages.properties = {
+          reason: "field-breakage",
+          fieldBreakages: propertiesBreakages
+        };
+      }
+    }
+    if ("patternProperties" in newSchema) {
+      const patternPropertiesBreakages = diffObjectProperties(
+        oldSchema.patternProperties,
+        newSchema.patternProperties,
+        origin,
+        oldSchema.required,
+        newSchema.required
+      );
+      if (Object.keys(patternPropertiesBreakages).length) {
+        breakages.patternProperties = {
+          reason: "field-breakage",
+          fieldBreakages: patternPropertiesBreakages
+        };
+      }
+    }
+    if ("additionalProperties" in newSchema || "additionalProperties" in oldSchema) {
+      throw new Error("additionalProperties is not supported");
+    }
+    if ("minProperties" in newSchema || "minProperties" in oldSchema) {
+      throw new Error("minProperties is not supported");
+    }
+    if ("maxProperties" in newSchema || "maxProperties" in oldSchema) {
+      throw new Error("maxProperties is not supported");
+    }
+  }
+  if (Object.keys(breakages).length) {
+    return {
+      reason: "field-breakage",
+      fieldBreakages: breakages
+    };
+  }
+  return null;
+}
+function diffObjectProperties(oldProperties, newProperties, origin, oldRequiredProperties = [], newRequiredProperties = []) {
+  const allProperties = /* @__PURE__ */ new Set([
+    ...Object.keys(oldProperties),
+    ...Object.keys(newProperties)
+  ]);
+  const breakages = {};
+  for (const propertyName of allProperties) {
+    const requiredBreakage = diffRequired(
+      oldProperties[propertyName],
+      newProperties[propertyName],
+      origin,
+      oldRequiredProperties.includes(propertyName),
+      newRequiredProperties.includes(propertyName)
+    );
+    if (requiredBreakage) {
+      breakages[propertyName] = requiredBreakage;
+    } else if (oldProperties[propertyName] && newProperties[propertyName]) {
+      const propertyBreakage = diffJSONSchema(
+        oldProperties[propertyName],
+        newProperties[propertyName],
+        origin
+      );
+      if (propertyBreakage) {
+        breakages[propertyName] = propertyBreakage;
+      }
+    }
+  }
+  return breakages;
+}
+function getReportingType(schema) {
+  if ("not" in schema) {
+    return "not";
+  }
+  if ("anyOf" in schema) {
+    return "anyOf";
+  }
+  if ("allOf" in schema) {
+    return "allOf";
+  }
+  if ("$ref" in schema) {
+    return "$ref";
+  }
+  if (schema.type && typeof schema.type === "string") {
+    return schema.type;
+  }
+  throw new Error(
+    "Subschema not supported, probably a conditional subschema. Check logs."
+  );
+}
+
 // router/procedures.ts
 import { Type as Type2 } from "@sinclair/typebox";
 function rpc({
@@ -964,6 +1426,14 @@ var RiverServer = class {
     this.transport.addEventListener("message", this.onMessage);
     this.transport.addEventListener("sessionStatus", this.onSessionStatus);
     this.log = transport.log;
+    this.transport.addEventListener("transportStatus", async ({ status }) => {
+      if (status !== "closed") {
+        return;
+      }
+      this.transport.removeEventListener("message", this.onMessage);
+      this.transport.removeEventListener("sessionStatus", this.onSessionStatus);
+      await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
+    });
   }
   get streams() {
     return this.streamMap;
@@ -1006,19 +1476,6 @@ var RiverServer = class {
     this.disconnectedSessions.delete(disconnectedClientId);
     this.clientStreams.delete(disconnectedClientId);
   };
-  async close() {
-    this.transport.removeEventListener("message", this.onMessage);
-    this.transport.removeEventListener("sessionStatus", this.onSessionStatus);
-    await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
-    for (const context of this.contextMap.values()) {
-      if (Symbol.dispose in context.state) {
-        const dispose = context.state[Symbol.dispose];
-        if (typeof dispose === "function") {
-          dispose();
-        }
-      }
-    }
-  }
   createNewProcStream(message) {
     if (!isStreamOpen(message.controlFlags)) {
       this.log?.error(
@@ -1393,6 +1850,7 @@ function createServerHandshakeOptions(schema, validate) {
 export {
   serializeSchema,
   ServiceSchema,
+  diffServerSchema,
   Procedure,
   pushable,
   UNCAUGHT_ERROR,
@@ -1404,4 +1862,4 @@ export {
   createClientHandshakeOptions,
   createServerHandshakeOptions
 };
-//# sourceMappingURL=chunk-WQRQFAP6.js.map
+//# sourceMappingURL=chunk-B323CECK.js.map