gremlin 3.8.0 → 4.0.0-beta.2

package/build/cjs/structure/io/binary/internals/VertexPropertySerializer.cjs

@@ -0,0 +1,163 @@
+"use strict";
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+const graph_js_1 = require("../../../graph.cjs");
+class VertexPropertySerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.VERTEXPROPERTY] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof graph_js_1.VertexProperty;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.VERTEXPROPERTY, 0x01]);
+            }
+            return buffer_1.Buffer.concat([
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {id}=null
+                this.ioc.listSerializer.serialize([], false), // {label}=empty list
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {value}=null
+                this.ioc.unspecifiedNullSerializer.serialize(null), // {parent}=null
+                this.ioc.listSerializer.serialize([], true), // {properties}=empty list
+            ]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.VERTEXPROPERTY, 0x00]));
+        }
+        // {id}
+        bufs.push(this.ioc.anySerializer.serialize(item.id));
+        // {label}
+        const labels = Array.isArray(item.label) ? item.label : item.label ? [item.label] : [];
+        bufs.push(this.ioc.listSerializer.serialize(labels, false));
+        // {value}
+        bufs.push(this.ioc.anySerializer.serialize(item.value));
+        // {parent}
+        bufs.push(this.ioc.unspecifiedNullSerializer.serialize(null));
+        // {properties}
+        bufs.push(this.ioc.listSerializer.serialize([], true));
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.Buffer)) {
+                throw new Error('buffer is missing');
+            }
+            if (buffer.length < 1) {
+                throw new Error('buffer is empty');
+            }
+            if (fullyQualifiedFormat) {
+                const type_code = cursor.readUInt8();
+                len++;
+                if (type_code !== this.ioc.DataType.VERTEXPROPERTY) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+                if (cursor.length < 1) {
+                    throw new Error('{value_flag} is missing');
+                }
+                const value_flag = cursor.readUInt8();
+                len++;
+                if (value_flag === 1) {
+                    return { v: null, len };
+                }
+                if (value_flag !== 0) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                cursor = cursor.slice(1);
+            }
+            // {id} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value}
+            let id, id_len;
+            try {
+                ({ v: id, len: id_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += id_len;
+            }
+            catch (err) {
+                err.message = '{id}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(id_len);
+            // {label} is a List value
+            let label, label_len;
+            try {
+                ({ v: label, len: label_len } = this.ioc.listSerializer.deserialize(cursor, false));
+                label = Array.isArray(label) && label.length > 0 ? label[0] : label;
+                len += label_len;
+            }
+            catch (err) {
+                err.message = '{label}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(label_len);
+            // {value} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value}
+            let value, value_len;
+            try {
+                ({ v: value, len: value_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += value_len;
+            }
+            catch (err) {
+                err.message = '{value}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(value_len);
+            // {parent} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value} which contains the parent Vertex.
+            // Note that as TinkerPop currently send "references" only, this value will always be null.
+            let parent_len;
+            try {
+                ({ len: parent_len } = this.ioc.unspecifiedNullSerializer.deserialize(cursor));
+                len += parent_len;
+            }
+            catch (err) {
+                err.message = '{parent}: ' + err.message;
+                throw err;
+            }
+            // TODO: should we verify that parent is null?
+            cursor = cursor.slice(parent_len);
+            // {properties} is a fully qualified typed value composed of {type_code}{type_info}{value_flag}{value} which contains properties. Note that as TinkerPop currently send "references" only, this value will always be null.
+            let properties, properties_len;
+            try {
+                ({ v: properties, len: properties_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += properties_len;
+            }
+            catch (err) {
+                err.message = '{properties}: ' + err.message;
+                throw err;
+            }
+            // TODO: should we verify that properties is null?
+            cursor = cursor.slice(properties_len);
+            // null properties are deserialized into empty lists
+            const vp_props = properties ? properties : [];
+            const v = new graph_js_1.VertexProperty(id, label, value, vp_props);
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = VertexPropertySerializer;

package/build/cjs/structure/io/binary/internals/VertexPropertySerializer.d.cts

@@ -0,0 +1,15 @@
+export default class VertexPropertySerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is VertexProperty<any, any, any, any>;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: null;
+        len: number;
+    } | {
+        v: VertexProperty<any, any, Record<string, any>, any>;
+        len: number;
+    };
+}
+import { VertexProperty } from '../../../graph.cjs';
+import { Buffer } from 'buffer';

package/build/cjs/structure/io/binary/internals/VertexSerializer.cjs

@@ -0,0 +1,128 @@
+"use strict";
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+const graph_js_1 = require("../../../graph.cjs");
+class VertexSerializer {
+    constructor(ioc) {
+        this.ioc = ioc;
+        this.ioc.serializers[ioc.DataType.VERTEX] = this;
+    }
+    canBeUsedFor(value) {
+        return value instanceof graph_js_1.Vertex;
+    }
+    serialize(item, fullyQualifiedFormat = true) {
+        if (item === undefined || item === null) {
+            if (fullyQualifiedFormat) {
+                return buffer_1.Buffer.from([this.ioc.DataType.VERTEX, 0x01]);
+            }
+            const id = [0x03, 0x00, 0x00, 0x00, 0x00, 0x00]; // String ''
+            const label = [0x00, 0x00, 0x00, 0x00]; // empty list
+            const properties = [0x09, 0x00, 0x00, 0x00, 0x00, 0x00]; // empty list
+            return buffer_1.Buffer.from([...id, ...label, ...properties]);
+        }
+        const bufs = [];
+        if (fullyQualifiedFormat) {
+            bufs.push(buffer_1.Buffer.from([this.ioc.DataType.VERTEX, 0x00]));
+        }
+        // {id}
+        bufs.push(this.ioc.anySerializer.serialize(item.id));
+        // {label}
+        const labels = Array.isArray(item.label) ? item.label : item.label ? [item.label] : [];
+        bufs.push(this.ioc.listSerializer.serialize(labels, false));
+        // {properties}
+        bufs.push(this.ioc.listSerializer.serialize([], true));
+        return buffer_1.Buffer.concat(bufs);
+    }
+    deserialize(buffer, fullyQualifiedFormat = true) {
+        let len = 0;
+        let cursor = buffer;
+        try {
+            if (buffer === undefined || buffer === null || !(buffer instanceof buffer_1.Buffer)) {
+                throw new Error('buffer is missing');
+            }
+            if (buffer.length < 1) {
+                throw new Error('buffer is empty');
+            }
+            if (fullyQualifiedFormat) {
+                const type_code = cursor.readUInt8();
+                len++;
+                if (type_code !== this.ioc.DataType.VERTEX) {
+                    throw new Error('unexpected {type_code}');
+                }
+                cursor = cursor.slice(1);
+                if (cursor.length < 1) {
+                    throw new Error('{value_flag} is missing');
+                }
+                const value_flag = cursor.readUInt8();
+                len++;
+                if (value_flag === 1) {
+                    return { v: null, len };
+                }
+                if (value_flag !== 0) {
+                    throw new Error('unexpected {value_flag}');
+                }
+                cursor = cursor.slice(1);
+            }
+            let id, id_len;
+            try {
+                ({ v: id, len: id_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += id_len;
+            }
+            catch (err) {
+                err.message = '{id}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(id_len);
+            let label, label_len;
+            try {
+                ({ v: label, len: label_len } = this.ioc.listSerializer.deserialize(cursor, false));
+                label = Array.isArray(label) && label.length > 0 ? label[0] : label;
+                len += label_len;
+            }
+            catch (err) {
+                err.message = '{label}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(label_len);
+            let properties, properties_len;
+            try {
+                ({ v: properties, len: properties_len } = this.ioc.anySerializer.deserialize(cursor));
+                len += properties_len;
+            }
+            catch (err) {
+                err.message = '{properties}: ' + err.message;
+                throw err;
+            }
+            cursor = cursor.slice(properties_len);
+            // null properties are deserialized into empty lists
+            const vertex_props = properties ? properties : [];
+            const v = new graph_js_1.Vertex(id, label, vertex_props);
+            return { v, len };
+        }
+        catch (err) {
+            throw this.ioc.utils.des_error({ serializer: this, args: arguments, cursor, err });
+        }
+    }
+}
+exports.default = VertexSerializer;

package/build/cjs/structure/io/binary/internals/VertexSerializer.d.cts

@@ -0,0 +1,17 @@
+export default class VertexSerializer {
+    constructor(ioc: any);
+    ioc: any;
+    canBeUsedFor(value: any): value is Vertex<any, any, any, any>;
+    serialize(item: any, fullyQualifiedFormat?: boolean): Buffer<ArrayBuffer>;
+    deserialize(buffer: any, fullyQualifiedFormat?: boolean, ...args: any[]): {
+        v: null;
+        len: number;
+    } | {
+        v: Vertex<any, Record<string, any>, any, {
+            [x: string]: [import("../../../graph.cjs").VertexProperty<string, any, Record<string, any>, any>, ...import("../../../graph.cjs").VertexProperty<string, any, Record<string, any>, any>[]];
+        }>;
+        len: number;
+    };
+}
+import { Vertex } from '../../../graph.cjs';
+import { Buffer } from 'buffer';

package/build/cjs/structure/io/binary/internals/utils.cjs

@@ -0,0 +1,53 @@
+"use strict";
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.des_error = void 0;
+/**
+ * @author Igor Ostapenko
+ */
+const buffer_1 = require("node:buffer");
+/*
+ * Deserialization error general constructor.
+ */
+const des_error = ({ serializer, args, cursor, err }) => {
+    if (cursor === undefined) {
+        cursor = args[0]; // buffer
+    }
+    let cursor_tail = '';
+    if (cursor instanceof buffer_1.Buffer) {
+        if (cursor.length > 32) {
+            cursor_tail = '...';
+        }
+        cursor = cursor.slice(0, 32).toString('hex');
+    }
+    const fullyQualifiedFormat = args[1];
+    const nullable = args[2];
+    let m = `${serializer.constructor.name}.deserialize(cursor=${cursor}${cursor_tail}`;
+    if (fullyQualifiedFormat !== undefined) {
+        m += `, fullyQualifiedFormat=${fullyQualifiedFormat}`;
+    }
+    if (nullable !== undefined) {
+        m += `, nullable=${nullable}`;
+    }
+    m += `): ${err.message.replace(/\.$/, '')}.`;
+    err.message = m;
+    return err;
+};
+exports.des_error = des_error;

package/build/cjs/structure/io/binary/internals/utils.d.cts

@@ -0,0 +1,6 @@
+export function des_error({ serializer, args, cursor, err }: {
+    serializer: any;
+    args: any;
+    cursor: any;
+    err: any;
+}): any;

package/build/cjs/utils.cjs

@@ -0,0 +1,142 @@
+"use strict";
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeferredPromise = exports.toArrayBuffer = exports.getUserAgent = exports.ImmutableMap = exports.emptyArray = exports.Long = void 0;
+exports.toLong = toLong;
+exports.getUuid = getUuid;
+exports.getUserAgentHeader = getUserAgentHeader;
+/**
+ * A module containing any utility functions.
+ * @author Jorge Bay Gondra
+ */
+const uuid = __importStar(require("uuid"));
+const gremlinVersion = '4.0.0-beta.2'; // DO NOT MODIFY - Configured automatically by Maven Replacer Plugin
+function toLong(value) {
+    return new Long(value);
+}
+class Long {
+    value;
+    constructor(value) {
+        this.value = value;
+        if (typeof value !== 'string' && typeof value !== 'number') {
+            throw new TypeError('The value must be a string or a number');
+        }
+    }
+}
+exports.Long = Long;
+function getUuid() {
+    // TODO: replace with `globalThis.crypto.randomUUID` once supported Node version is bump to >=19
+    return uuid.v4();
+}
+exports.emptyArray = Object.freeze([]);
+class ImmutableMap extends Map {
+    constructor(iterable) {
+        super(iterable);
+    }
+    set() {
+        return this;
+    }
+    ['delete']() {
+        return false;
+    }
+    clear() { }
+}
+exports.ImmutableMap = ImmutableMap;
+async function generateNodeUserAgent() {
+    const os = await import('node:os');
+    const applicationName = (process?.env.npm_package_name ?? 'NotAvailable').replace('_', ' ');
+    let runtimeVersion;
+    let osName;
+    let osVersion;
+    let cpuArch;
+    runtimeVersion = osName = osVersion = cpuArch = 'NotAvailable';
+    if (process != null) {
+        if (process.version) {
+            runtimeVersion = process.version.replace(' ', '_');
+        }
+        if (process.arch) {
+            cpuArch = process.arch.replace(' ', '_');
+        }
+    }
+    if (os != null) {
+        osName = os.platform().replace(' ', '_');
+        osVersion = os.release().replace(' ', '_');
+    }
+    const userAgent = `${applicationName} Gremlin-Javascript.${gremlinVersion} ${runtimeVersion} ${osName}.${osVersion} ${cpuArch}`;
+    return userAgent;
+}
+function getUserAgentHeader() {
+    return 'User-Agent';
+}
+const getUserAgent = async () => {
+    if ('navigator' in globalThis) {
+        return globalThis.navigator.userAgent;
+    }
+    if (process?.versions?.node !== undefined) {
+        return await generateNodeUserAgent();
+    }
+    return undefined;
+};
+exports.getUserAgent = getUserAgent;
+const toArrayBuffer = (buffer) => buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+exports.toArrayBuffer = toArrayBuffer;
+const DeferredPromise = () => {
+    let resolve = (value) => { };
+    let reject = (reason) => { };
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    return Object.assign(promise, { resolve, reject });
+};
+exports.DeferredPromise = DeferredPromise;

package/build/cjs/utils.d.cts

@@ -0,0 +1,20 @@
+export declare function toLong(value: number | string): Long;
+export declare class Long {
+    value: number | string;
+    constructor(value: number | string);
+}
+export declare function getUuid(): string;
+export declare const emptyArray: any[];
+export declare class ImmutableMap<K, V> extends Map<K, V> implements ReadonlyMap<K, V> {
+    constructor(iterable?: Iterable<[K, V]>);
+    set(): this;
+    ['delete'](): boolean;
+    clear(): void;
+}
+export declare function getUserAgentHeader(): string;
+export declare const getUserAgent: () => Promise<string | undefined>;
+export declare const toArrayBuffer: (buffer: Buffer) => ArrayBuffer | SharedArrayBuffer;
+export declare const DeferredPromise: <T>() => Promise<T> & {
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+};

package/build/esm/driver/auth.d.ts

@@ -0,0 +1,9 @@
+import type { RequestInterceptor } from './connection.js';
+export declare function basic(username: string, password: string): RequestInterceptor;
+export interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+}
+export type AwsCredentialsProvider = () => AwsCredentials | Promise<AwsCredentials>;
+export declare function sigv4(region: string, service: string, credentialsProvider?: AwsCredentialsProvider): RequestInterceptor;

package/build/esm/driver/auth.js

@@ -0,0 +1,65 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+import { Buffer } from 'buffer';
+export function basic(username, password) {
+    return (request) => {
+        request.headers['authorization'] = 'Basic ' + Buffer.from(`${username}:${password}`).toString('base64');
+        return request;
+    };
+}
+export function sigv4(region, service, credentialsProvider) {
+    let signer;
+    let resolvedProvider;
+    return async (request) => {
+        // Lazy-initialize signer and credentials provider on first use
+        if (!signer) {
+            const { SignatureV4 } = await import('@smithy/signature-v4');
+            const { Hash } = await import('@smithy/hash-node');
+            if (credentialsProvider) {
+                resolvedProvider = credentialsProvider;
+            }
+            else {
+                const { fromNodeProviderChain } = await import('@aws-sdk/credential-providers');
+                const chain = fromNodeProviderChain({ clientConfig: { region } });
+                resolvedProvider = () => chain();
+            }
+            signer = new SignatureV4({
+                service,
+                region,
+                sha256: Hash.bind(null, 'sha256'),
+                credentials: () => Promise.resolve(resolvedProvider()),
+            });
+        }
+        const url = new URL(request.url);
+        const signed = await signer.sign({
+            method: request.method,
+            protocol: url.protocol,
+            hostname: url.hostname,
+            port: url.port ? Number(url.port) : undefined,
+            path: url.pathname + url.search,
+            headers: {
+                ...request.headers,
+                host: url.host,
+            },
+            body: request.body,
+        });
+        request.headers = signed.headers;
+        return request;
+    };
+}