effect-start 0.23.0 → 0.25.0

package/dist/RouteTree.js

@@ -1,93 +1,119 @@
-import * as Predicate from "effect/Predicate";
-import * as PathPattern from "./PathPattern.js";
-import * as Route from "./Route.js";
-const TypeId = Symbol.for("effect-start/RouteTree");
-const RouteTreeRoutes = Symbol();
-const LayerKey = "*";
+import * as Predicate from "effect/Predicate"
+import * as PathPattern from "./PathPattern.js"
+import * as Route from "./Route.js"
+
+const TypeId = Symbol.for("effect-start/RouteTree")
+const RouteTreeRoutes = Symbol()
+
+const LayerKey = "*"
+
 function routes(tree) {
-    return tree[RouteTreeRoutes];
+  return tree[RouteTreeRoutes]
 }
+
 // segment priority: static (0) < :param (1) < :param? (2) < :param+ (3) < :param* (4)
 function sortScore(path) {
-    const segments = path.split("/");
-    const greedyIdx = segments.findIndex((s) => s.endsWith("*") || s.endsWith("+"));
-    const maxPriority = Math.max(...segments.map((s) => !s.startsWith(":") ? 0 : s.endsWith("*") ? 4 : s.endsWith("+") ? 3 : s.endsWith("?") ? 2 : 1), 0);
-    return greedyIdx === -1
-        ? // non-greedy: sort by depth, then by max segment priority
-            (segments.length << 16) + (maxPriority << 8)
-        : // greedy: sort after non-greedy, by greedy position (later = first), then priority
-            (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8);
+  const segments = path.split("/")
+  const greedyIdx = segments.findIndex((s) => s.endsWith("*") || s.endsWith("+"))
+  const maxPriority = Math.max(
+    ...segments.map((s) =>
+      !s.startsWith(":") ? 0 : s.endsWith("*") ? 4 : s.endsWith("+") ? 3 : s.endsWith("?") ? 2 : 1,
+    ),
+    0,
+  )
+
+  return greedyIdx === -1
+    ? // non-greedy: sort by depth, then by max segment priority
+      (segments.length << 16) + (maxPriority << 8)
+    : // greedy: sort after non-greedy, by greedy position (later = first), then priority
+      (1 << 24) + ((16 - greedyIdx) << 16) + (maxPriority << 8)
 }
+
 function sortRoutes(input) {
-    const keys = Object.keys(input).sort((a, b) => sortScore(a) - sortScore(b) || a.localeCompare(b));
-    const sorted = {};
-    for (const key of keys) {
-        sorted[key] = input[key];
-    }
-    return sorted;
+  const keys = Object.keys(input).sort((a, b) => sortScore(a) - sortScore(b) || a.localeCompare(b))
+  const sorted = {}
+  for (const key of keys) {
+    sorted[key] = input[key]
+  }
+  return sorted
 }
-export function make(input) {
-    const layerRoutes = [...(input[LayerKey] ?? [])];
-    const merged = {};
-    function flatten(map, prefix, layers) {
-        for (const key of Object.keys(map)) {
-            if (key === LayerKey)
-                continue;
-            const path = key;
-            const entry = map[path];
-            const fullPath = `${prefix}${path}`;
-            if (isRouteTree(entry)) {
-                flatten(routes(entry), fullPath, layers);
-            }
-            else {
-                merged[fullPath] = [...layers, ...entry];
-            }
-        }
+
+export function make(
+  input,
+) {
+  const layerRoutes = [...(input[LayerKey] ?? [])]
+  const merged = {}
+
+  function flatten(map, prefix, layers) {
+    for (const key of Object.keys(map)) {
+      if (key === LayerKey) continue
+      const path = key
+      const entry = map[path]
+      const fullPath = `${prefix}${path}`
+
+      if (isRouteTree(entry)) {
+        flatten(routes(entry), fullPath, layers)
+      } else {
+        merged[fullPath] = [...layers, ...(entry)]
+      }
     }
-    flatten(input, "", layerRoutes);
-    return {
-        [TypeId]: TypeId,
-        [RouteTreeRoutes]: sortRoutes(merged),
-    };
+  }
+
+  flatten(input, "", layerRoutes)
+
+  return {
+    [TypeId]: TypeId,
+    [RouteTreeRoutes]: sortRoutes(merged),
+  }
 }
-function* flattenRoutes(path, routes) {
-    for (const route of routes) {
-        const descriptor = {
-            ...route[Route.RouteDescriptor],
-            path,
-        };
-        yield Route.make(route.handler, descriptor);
+
+function* flattenRoutes(
+  path,
+  routes,
+) {
+  for (const route of routes) {
+    const descriptor = {
+      ...route[Route.RouteDescriptor],
+      path,
     }
+    yield Route.make(route.handler, descriptor)
+  }
 }
+
 export function* walk(tree) {
-    const _routes = routes(tree);
-    for (const path of Object.keys(_routes)) {
-        yield* flattenRoutes(path, _routes[path]);
-    }
+  const _routes = routes(tree)
+
+  for (const path of Object.keys(_routes)) {
+    yield* flattenRoutes(path, _routes[path])
+  }
 }
+
 export function merge(a, b) {
-    const combined = { ...routes(a) };
-    for (const [path, items] of Object.entries(routes(b))) {
-        const key = path;
-        combined[key] = combined[key] ? [...combined[key], ...items] : items;
-    }
-    return {
-        [TypeId]: TypeId,
-        [RouteTreeRoutes]: sortRoutes(combined),
-    };
+  const combined = { ...routes(a) }
+  for (const [path, items] of Object.entries(routes(b))) {
+    const key = path
+    combined[key] = combined[key] ? [...combined[key], ...items] : items
+  }
+  return {
+    [TypeId]: TypeId,
+    [RouteTreeRoutes]: sortRoutes(combined),
+  }
 }
+
 export function isRouteTree(input) {
-    return Predicate.hasProperty(input, TypeId);
+  return Predicate.hasProperty(input, TypeId)
 }
+
 export function lookup(tree, method, path) {
-    for (const route of walk(tree)) {
-        const descriptor = Route.descriptor(route);
-        if (descriptor.method !== "*" && descriptor.method !== method)
-            continue;
-        const params = PathPattern.match(descriptor.path, path);
-        if (params !== null) {
-            return { route, params };
-        }
+  for (const route of walk(tree)) {
+    const descriptor = Route.descriptor(route)
+
+    if (descriptor.method !== "*" && descriptor.method !== method) continue
+
+    const params = PathPattern.match(descriptor.path, path)
+    if (params !== null) {
+      return { route, params }
     }
-    return null;
+  }
+  return null
 }

package/dist/RouteTrie.js

@@ -1,152 +1,179 @@
-import * as PathPattern from "./PathPattern.js";
-import * as Route from "./Route.js";
+import * as PathPattern from "./PathPattern.js"
+import * as Route from "./Route.js"
+
 function createNode() {
-    return {
-        children: {},
-        paramChild: null,
-        paramName: null,
-        requiredWildcardChild: null,
-        requiredWildcardName: null,
-        optionalWildcardChild: null,
-        optionalWildcardName: null,
-        routes: [],
-    };
+  return {
+    children: {},
+    paramChild: null,
+    paramName: null,
+    requiredWildcardChild: null,
+    requiredWildcardName: null,
+    optionalWildcardChild: null,
+    optionalWildcardName: null,
+    routes: [],
+  }
 }
+
 function insertRoute(node, segments, route) {
-    if (segments.length === 0) {
-        node.routes.push(route);
-        return;
+  if (segments.length === 0) {
+    node.routes.push(route)
+    return
+  }
+
+  const segment = segments[0]
+  const rest = segments.slice(1)
+
+  if (segment.startsWith(":")) {
+    const name = segment.slice(1)
+
+    if (name.endsWith("+")) {
+      if (!node.requiredWildcardChild) {
+        node.requiredWildcardChild = createNode()
+      }
+      node.requiredWildcardChild.requiredWildcardName = name.slice(0, -1)
+      node.requiredWildcardChild.routes.push(route)
+    } else if (name.endsWith("*")) {
+      if (!node.optionalWildcardChild) {
+        node.optionalWildcardChild = createNode()
+      }
+      node.optionalWildcardChild.optionalWildcardName = name.slice(0, -1)
+      node.optionalWildcardChild.routes.push(route)
+    } else if (name.endsWith("?")) {
+      if (!node.paramChild) {
+        node.paramChild = createNode()
+      }
+      node.paramChild.paramName = name.slice(0, -1)
+      insertRoute(node.paramChild, rest, route)
+      insertRoute(node, rest, route)
+    } else {
+      if (!node.paramChild) {
+        node.paramChild = createNode()
+      }
+      node.paramChild.paramName = name
+      insertRoute(node.paramChild, rest, route)
     }
-    const segment = segments[0];
-    const rest = segments.slice(1);
-    if (segment.startsWith(":")) {
-        const name = segment.slice(1);
-        if (name.endsWith("+")) {
-            if (!node.requiredWildcardChild) {
-                node.requiredWildcardChild = createNode();
-            }
-            node.requiredWildcardChild.requiredWildcardName = name.slice(0, -1);
-            node.requiredWildcardChild.routes.push(route);
-        }
-        else if (name.endsWith("*")) {
-            if (!node.optionalWildcardChild) {
-                node.optionalWildcardChild = createNode();
-            }
-            node.optionalWildcardChild.optionalWildcardName = name.slice(0, -1);
-            node.optionalWildcardChild.routes.push(route);
-        }
-        else if (name.endsWith("?")) {
-            if (!node.paramChild) {
-                node.paramChild = createNode();
-            }
-            node.paramChild.paramName = name.slice(0, -1);
-            insertRoute(node.paramChild, rest, route);
-            insertRoute(node, rest, route);
-        }
-        else {
-            if (!node.paramChild) {
-                node.paramChild = createNode();
-            }
-            node.paramChild.paramName = name;
-            insertRoute(node.paramChild, rest, route);
-        }
-    }
-    else {
-        if (!node.children[segment]) {
-            node.children[segment] = createNode();
-        }
-        insertRoute(node.children[segment], rest, route);
+  } else {
+    if (!node.children[segment]) {
+      node.children[segment] = createNode()
     }
+    insertRoute(node.children[segment], rest, route)
+  }
 }
-function collectRoutes(items, parentPath, parentMethod) {
-    const results = [];
-    for (const item of items) {
-        const desc = Route.descriptor(item);
-        const currentPath = typeof desc?.path === "string" ? parentPath + desc.path : parentPath;
-        const currentMethod = desc?.method ?? parentMethod;
-        if (Route.isRoute(item)) {
-            if (currentPath !== "") {
-                results.push({
-                    route: item,
-                    method: currentMethod,
-                    path: currentPath,
-                });
-            }
-        }
-        else {
-            const nestedItems = Route.items(item);
-            results.push(...collectRoutes(nestedItems, currentPath, currentMethod));
-        }
+
+function collectRoutes(
+  items,
+  parentPath,
+  parentMethod,
+) {
+  const results = []
+
+  for (const item of items) {
+    const desc = Route.descriptor(item)
+    const currentPath = typeof desc?.path === "string" ? parentPath + desc.path : parentPath
+    const currentMethod = desc?.method ?? parentMethod
+
+    if (Route.isRoute(item)) {
+      if (currentPath !== "") {
+        results.push({
+          route: item,
+          method: currentMethod,
+          path: currentPath,
+        })
+      }
+    } else {
+      const nestedItems = Route.items(item)
+      results.push(...collectRoutes(nestedItems, currentPath, currentMethod))
     }
-    return results;
+  }
+
+  return results
 }
+
 export function make(set) {
-    const methods = {};
-    const collected = collectRoutes(Route.items(set), "", "*");
-    for (const { route, method, path } of collected) {
-        if (!methods[method]) {
-            methods[method] = createNode();
-        }
-        const result = PathPattern.validate(path);
-        if (!result.ok) {
-            throw new Error(result.error);
-        }
-        insertRoute(methods[method], result.segments, route);
+  const methods = {}
+  const collected = collectRoutes(Route.items(set), "", "*")
+
+  for (const { route, method, path } of collected) {
+    if (!methods[method]) {
+      methods[method] = createNode()
+    }
+    const result = PathPattern.validate(path)
+    if (!result.ok) {
+      throw new Error(result.error)
     }
-    return { methods };
+    insertRoute(methods[method], result.segments, route)
+  }
+
+  return { methods }
 }
-function lookupNode(node, segments, params) {
-    const results = [];
-    if (segments.length === 0) {
-        for (const route of node.routes) {
-            results.push({ route, params });
-        }
-        if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
-            for (const route of node.optionalWildcardChild.routes) {
-                results.push({ route, params });
-            }
-        }
-        return results;
+
+function lookupNode(
+  node,
+  segments,
+  params,
+) {
+  const results = []
+
+  if (segments.length === 0) {
+    for (const route of node.routes) {
+      results.push({ route, params })
     }
-    const segment = segments[0];
-    const rest = segments.slice(1);
-    if (node.children[segment]) {
-        results.push(...lookupNode(node.children[segment], rest, params));
+    if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
+      for (const route of node.optionalWildcardChild.routes) {
+        results.push({ route, params })
+      }
     }
-    if (node.paramChild && node.paramChild.paramName) {
-        const newParams = { ...params, [node.paramChild.paramName]: segment };
-        results.push(...lookupNode(node.paramChild, rest, newParams));
+    return results
+  }
+
+  const segment = segments[0]
+  const rest = segments.slice(1)
+
+  if (node.children[segment]) {
+    results.push(...lookupNode(node.children[segment], rest, params))
+  }
+
+  if (node.paramChild && node.paramChild.paramName) {
+    const newParams = { ...params, [node.paramChild.paramName]: segment }
+    results.push(...lookupNode(node.paramChild, rest, newParams))
+  }
+
+  if (node.requiredWildcardChild && node.requiredWildcardChild.requiredWildcardName) {
+    const wildcardValue = segments.join("/")
+    const newParams = {
+      ...params,
+      [node.requiredWildcardChild.requiredWildcardName]: wildcardValue,
     }
-    if (node.requiredWildcardChild && node.requiredWildcardChild.requiredWildcardName) {
-        const wildcardValue = segments.join("/");
-        const newParams = {
-            ...params,
-            [node.requiredWildcardChild.requiredWildcardName]: wildcardValue,
-        };
-        for (const route of node.requiredWildcardChild.routes) {
-            results.push({ route, params: newParams });
-        }
+    for (const route of node.requiredWildcardChild.routes) {
+      results.push({ route, params: newParams })
     }
-    if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
-        const wildcardValue = segments.join("/");
-        const newParams = {
-            ...params,
-            [node.optionalWildcardChild.optionalWildcardName]: wildcardValue,
-        };
-        for (const route of node.optionalWildcardChild.routes) {
-            results.push({ route, params: newParams });
-        }
+  }
+
+  if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
+    const wildcardValue = segments.join("/")
+    const newParams = {
+      ...params,
+      [node.optionalWildcardChild.optionalWildcardName]: wildcardValue,
     }
-    return results;
+    for (const route of node.optionalWildcardChild.routes) {
+      results.push({ route, params: newParams })
+    }
+  }
+
+  return results
 }
+
 export function lookup(trie, method, path) {
-    const segments = path.split("/").filter(Boolean);
-    const results = [];
-    if (trie.methods[method]) {
-        results.push(...lookupNode(trie.methods[method], segments, {}));
-    }
-    if (method !== "*" && trie.methods["*"]) {
-        results.push(...lookupNode(trie.methods["*"], segments, {}));
-    }
-    return results;
+  const segments = path.split("/").filter(Boolean)
+  const results = []
+
+  if (trie.methods[method]) {
+    results.push(...lookupNode(trie.methods[method], segments, {}))
+  }
+
+  if (method !== "*" && trie.methods["*"]) {
+    results.push(...lookupNode(trie.methods["*"], segments, {}))
+  }
+
+  return results
 }

package/dist/SchemaExtra.js

@@ -1,74 +1,99 @@
-import * as SchemaAST from "effect/SchemaAST";
+import * as Function from "effect/Function"
+import * as SchemaAST from "effect/SchemaAST"
+
 export function getBaseSchemaAST(schema) {
-    let current = schema.ast;
-    while (SchemaAST.isRefinement(current) || SchemaAST.isTransformation(current)) {
-        current = current.from;
-    }
-    return current;
+  let current = schema.ast
+
+  while (SchemaAST.isRefinement(current) || SchemaAST.isTransformation(current)) {
+    current = current.from
+  }
+
+  return current
 }
+
 export function isOptional(schema) {
-    const ast = schema.ast;
-    if (ast._tag === "Union") {
-        return ast.types.some((t) => t._tag === "UndefinedKeyword");
-    }
-    return false;
+  const ast = schema.ast
+
+  if (ast._tag === "Union") {
+    return ast.types.some((t) => t._tag === "UndefinedKeyword")
+  }
+
+  return false
 }
-export function schemaEqual(userSchema, expectedSchema) {
-    if (!userSchema && !expectedSchema) {
-        return true;
-    }
-    if (!userSchema || !expectedSchema) {
-        return false;
+
+export function schemaEqual(
+  userSchema,
+  expectedSchema,
+) {
+  if (!userSchema && !expectedSchema) {
+    return true
+  }
+  if (!userSchema || !expectedSchema) {
+    return false
+  }
+
+  const userFields = userSchema.fields
+  const expectedFields = expectedSchema.fields
+
+  const userKeys = Object.keys(userFields).sort()
+  const expectedKeys = Object.keys(expectedFields).sort()
+
+  if (userKeys.length !== expectedKeys.length) {
+    return false
+  }
+
+  for (let i = 0; i < userKeys.length; i++) {
+    if (userKeys[i] !== expectedKeys[i]) {
+      return false
     }
-    const userFields = userSchema.fields;
-    const expectedFields = expectedSchema.fields;
-    const userKeys = Object.keys(userFields).sort();
-    const expectedKeys = Object.keys(expectedFields).sort();
-    if (userKeys.length !== expectedKeys.length) {
-        return false;
+  }
+
+  for (const key of userKeys) {
+    const userFieldSchema = userFields[key]
+    const expectedFieldSchema = expectedFields[key]
+
+    const userOptional = isOptional(userFieldSchema)
+    const expectedOptional = isOptional(expectedFieldSchema)
+
+    if (userOptional !== expectedOptional) {
+      return false
     }
-    for (let i = 0; i < userKeys.length; i++) {
-        if (userKeys[i] !== expectedKeys[i]) {
-            return false;
-        }
+
+    const userBaseAST = getBaseSchemaAST(userFieldSchema)
+    const expectedBaseAST = getBaseSchemaAST(expectedFieldSchema)
+
+    if (userBaseAST._tag !== expectedBaseAST._tag) {
+      return false
     }
-    for (const key of userKeys) {
-        const userFieldSchema = userFields[key];
-        const expectedFieldSchema = expectedFields[key];
-        const userOptional = isOptional(userFieldSchema);
-        const expectedOptional = isOptional(expectedFieldSchema);
-        if (userOptional !== expectedOptional) {
-            return false;
-        }
-        const userBaseAST = getBaseSchemaAST(userFieldSchema);
-        const expectedBaseAST = getBaseSchemaAST(expectedFieldSchema);
-        if (userBaseAST._tag !== expectedBaseAST._tag) {
-            return false;
-        }
-    }
-    return true;
+  }
+
+  return true
 }
+
 export function getSchemaTypeName(schema) {
-    const baseAST = getBaseSchemaAST(schema);
-    switch (baseAST._tag) {
-        case "StringKeyword":
-            return "Schema.String";
-        case "NumberKeyword":
-            return "Schema.Number";
-        case "BooleanKeyword":
-            return "Schema.Boolean";
-        default:
-            return "Schema.String";
-    }
+  const baseAST = getBaseSchemaAST(schema)
+  switch (baseAST._tag) {
+    case "StringKeyword":
+      return "Schema.String"
+    case "NumberKeyword":
+      return "Schema.Number"
+    case "BooleanKeyword":
+      return "Schema.Boolean"
+    default:
+      return "Schema.String"
+  }
 }
+
 export function formatSchemaCode(schema) {
-    const fields = schema.fields;
-    const fieldStrings = [];
-    for (const [key, fieldSchema] of Object.entries(fields)) {
-        const optional = isOptional(fieldSchema);
-        const typeName = getSchemaTypeName(fieldSchema);
-        const fieldStr = optional ? `${key}?: ${typeName}` : `${key}: ${typeName}`;
-        fieldStrings.push(fieldStr);
-    }
-    return `{ ${fieldStrings.join(", ")} }`;
+  const fields = schema.fields
+  const fieldStrings = []
+
+  for (const [key, fieldSchema] of Object.entries(fields)) {
+    const optional = isOptional(fieldSchema)
+    const typeName = getSchemaTypeName(fieldSchema)
+    const fieldStr = optional ? `${key}?: ${typeName}` : `${key}: ${typeName}`
+    fieldStrings.push(fieldStr)
+  }
+
+  return `{ ${fieldStrings.join(", ")} }`
 }