@scalar/workspace-store 0.60.0 → 0.61.0

package/dist/server.js

@@ -1,17 +1,20 @@
-import fs from 'node:fs/promises';
 import { cwd } from 'node:process';
 import { upgrade as upgradeAsyncApi } from '@scalar/asyncapi-upgrader';
+import { isHttpMethod } from '@scalar/helpers/http/is-http-method';
 import { parseJsonPointerSegments } from '@scalar/helpers/json/parse-json-pointer-segments';
 import { getValueAtPath } from '@scalar/helpers/object/get-value-at-path';
 import { preventPollution } from '@scalar/helpers/object/prevent-pollution';
 import { extensions as bundleExtensions } from '@scalar/json-magic/bundle';
 import { fetchUrls, readFiles } from '@scalar/json-magic/bundle/plugins/node';
 import { escapeJsonPointer } from '@scalar/json-magic/helpers/escape-json-pointer';
+import { unescapeJsonPointer } from '@scalar/json-magic/helpers/unescape-json-pointer';
 import { createMagicProxy, getRaw } from '@scalar/json-magic/magic-proxy';
 import { upgrade } from '@scalar/openapi-upgrader';
 import { asyncApiObjectSchema } from '@scalar/schemas/asyncapi/3.1';
 import { coerce } from '@scalar/validation';
+import { createChunkWriter } from './helpers/create-chunk-writer.js';
 import { deepClone } from './helpers/deep-clone.js';
+import { encodeChunkName } from './helpers/encode-chunk-name.js';
 import { forEachPathItemOperation, getResolvedPathItem } from './helpers/for-each-path-item-operation.js';
 import { keyOf } from './helpers/general.js';
 import { getResolvedRef } from './helpers/get-resolved-ref.js';
@@ -20,10 +23,9 @@ import { createNavigation, traverseAsyncApiDocument } from './navigation/index.j
 import { extensions } from './schemas/extensions.js';
 import { isAsyncApiDocument } from './schemas/type-guards.js';
 import { coerceValue } from './schemas/typebox-coerce.js';
-import { OpenAPIDocumentSchema, } from './schemas/v3.1/strict/openapi-document.js';
+import { OpenAPIDocumentSchema, } from './schemas/v3.2/strict/openapi-document.js';
 const DEFAULT_ASSETS_FOLDER = 'assets';
 export const WORKSPACE_FILE_NAME = 'scalar-workspace.json';
-const httpMethods = new Set(['get', 'put', 'post', 'delete', 'options', 'head', 'patch', 'trace']);
 /**
  * Wraps a document so local `$ref`s resolve while the store inspects it.
  *
@@ -100,11 +102,14 @@ const preserveBundledExternals = (source, target) => {
  */
 export function filterHttpMethodsOnly(paths) {
     const result = {};
-    // Todo: skip extension properties
     for (const [path, pathItemRef] of Object.entries(paths)) {
+        // Paths Object extensions can contain objects that resemble HTTP operations.
+        if (path.startsWith('x-')) {
+            continue;
+        }
         const filteredMethods = {};
         forEachPathItemOperation(pathItemRef, (method, operation) => {
-            if (httpMethods.has(method.toLowerCase())) {
+            if (isHttpMethod(method)) {
                 // Unwrapped because the caller hands us a resolved document. A magic proxy enumerates a
                 // virtual `$ref-value`, so storing one would inline every referenced component beside its
                 // `$ref` when the chunk is written — and a self-referential schema would never finish
@@ -153,10 +158,7 @@ export function externalizeComponentReferences(document, meta) {
         Object.keys(component).forEach((name) => {
             const ref = meta.mode === 'ssr'
                 ? `${meta.baseUrl}/${meta.name}/components/${type}/${name}#`
-                : // Escape the type and name so the static reference matches the escaped filename written
-                    // by generateWorkspaceChunks, and so a key like `../../evil` cannot point outside the
-                    // chunks directory.
-                    `./chunks/${meta.name}/components/${escapeJsonPointer(type)}/${escapeJsonPointer(name)}.json#`;
+                : `./chunks/${encodeChunkName(meta.name)}/components/${encodeChunkName(type)}/${encodeChunkName(name)}.json#`;
             result[type][name] = { '$ref': ref, $global: true };
         });
     });
@@ -179,10 +181,10 @@ export function externalizePathReferences(document, meta) {
         result[path] = {};
         const escapedPath = escapeJsonPointer(path);
         keyOf(pathItemRecord).forEach((type) => {
-            if (httpMethods.has(type)) {
+            if (isHttpMethod(type)) {
                 const ref = meta.mode === 'ssr'
                     ? `${meta.baseUrl}/${meta.name}/operations/${escapedPath}/${type}#`
-                    : `./chunks/${meta.name}/operations/${escapedPath}/${type}.json#`;
+                    : `./chunks/${encodeChunkName(meta.name)}/operations/${encodeChunkName(path)}/${type}.json#`;
                 result[path][type] = { '$ref': ref, $global: true };
             }
             else if (type !== '$ref' && type !== '$ref-value') {
@@ -415,32 +417,26 @@ export async function createServerWorkspaceStore(workspaceProps) {
             }
             // Write the workspace document
             const basePath = `${cwd()}/${workspaceProps.directory ?? DEFAULT_ASSETS_FOLDER}`;
-            await fs.mkdir(basePath, { recursive: true });
-            // Write the workspace contents on the file system
-            await fs.writeFile(`${basePath}/${WORKSPACE_FILE_NAME}`, JSON.stringify(workspace));
-            // Write the chunks
+            const writeChunk = await createChunkWriter(basePath);
+            await writeChunk([WORKSPACE_FILE_NAME], workspace);
             for (const [name, { components, operations }] of Object.entries(assets)) {
-                // Write the components chunks
                 if (components) {
                     for (const [type, component] of Object.entries(components)) {
-                        // Escape the component type and key the same way operation paths are escaped. Component
-                        // keys come from the OpenAPI document, so a key like `../../evil` would otherwise let a
-                        // document write chunk files outside the assets directory. escapeJsonPointer turns every
-                        // `/` into `~1`, collapsing the value into a single safe path segment.
-                        const componentPath = `${basePath}/chunks/${name}/components/${escapeJsonPointer(type)}`;
-                        await fs.mkdir(componentPath, { recursive: true });
                         for (const [key, value] of Object.entries(component)) {
-                            await fs.writeFile(`${componentPath}/${escapeJsonPointer(key)}.json`, JSON.stringify(value));
+                            await writeChunk(['chunks', encodeChunkName(name), 'components', encodeChunkName(type), `${encodeChunkName(key)}.json`], value);
                         }
                     }
                 }
-                // Write the operations chunks
                 if (operations) {
                     for (const [path, methods] of Object.entries(operations)) {
-                        const operationPath = `${basePath}/chunks/${name}/operations/${path}`;
-                        await fs.mkdir(operationPath, { recursive: true });
                         for (const [method, operation] of Object.entries(methods)) {
-                            await fs.writeFile(`${operationPath}/${method}.json`, JSON.stringify(operation));
+                            await writeChunk([
+                                'chunks',
+                                encodeChunkName(name),
+                                'operations',
+                                encodeChunkName(unescapeJsonPointer(path)),
+                                `${encodeChunkName(method)}.json`,
+                            ], operation);
                         }
                     }
                 }

package/package.json

@@ -16,7 +16,7 @@
     "openapi",
     "scalar"
   ],
-  "version": "0.60.0",
+  "version": "0.61.0",
   "engines": {
     "node": ">=22"
   },
@@ -148,14 +148,14 @@
     "type-fest": "^5.8.0",
     "vue": "^3.5.40",
     "yaml": "^2.9.0",
-    "@scalar/asyncapi-upgrader": "0.1.9",
-    "@scalar/helpers": "0.11.3",
-    "@scalar/json-magic": "0.13.4",
-    "@scalar/openapi-upgrader": "0.2.15",
-    "@scalar/schemas": "0.9.0",
-    "@scalar/snippetz": "0.9.30",
+    "@scalar/helpers": "0.12.0",
+    "@scalar/asyncapi-upgrader": "0.1.10",
+    "@scalar/openapi-upgrader": "0.2.16",
+    "@scalar/schemas": "0.10.0",
+    "@scalar/snippetz": "0.9.31",
+    "@scalar/types": "0.20.0",
     "@scalar/validation": "0.6.3",
-    "@scalar/types": "0.19.0"
+    "@scalar/json-magic": "0.13.5"
   },
   "devDependencies": {
     "@google-cloud/storage": "7.21.0",