@cfworker/cosmos 2.0.0 → 3.0.0

package/dist/cjs/client.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmosClient = void 0;
+const response_js_1 = require("./response.js");
+const retry_js_1 = require("./retry.js");
+const session_js_1 = require("./session.js");
+const signer_js_1 = require("./signer.js");
+const util_js_1 = require("./util.js");
+class CosmosClient {
+    endpoint;
+    signer;
+    retryPolicy;
+    consistencyLevel;
+    dbId;
+    collId;
+    enableCrossPartitionQueries;
+    systemFetch;
+    sessions;
+    requestCharges = 0;
+    retries = { count: 0, delayMs: 0 };
+    constructor(config) {
+        let { endpoint, masterKey } = 'connectionString' in config
+            ? (0, util_js_1.parseConnectionString)(config.connectionString)
+            : config;
+        if (endpoint.endsWith('/')) {
+            endpoint = endpoint.slice(0, -1);
+        }
+        this.endpoint = endpoint;
+        this.signer = (0, signer_js_1.getSigner)(masterKey);
+        this.retryPolicy = config.retryPolicy ?? retry_js_1.defaultRetryPolicy;
+        this.consistencyLevel = config.consistencyLevel ?? 'Session';
+        this.dbId = config.dbId;
+        this.collId = config.collId;
+        this.enableCrossPartitionQueries =
+            config.enableCrossPartitionQueries ?? true;
+        this.sessions = config.sessions ?? new session_js_1.DefaultSessionContainer();
+        this.systemFetch = config.fetch ?? fetch.bind(globalThis);
+    }
+    async getDatabases(args = {}) {
+        const url = this.endpoint + `/dbs`;
+        const request = new Request(url, { method: 'GET' });
+        this.setHeaders(request.headers, args);
+        const response = await this.fetchWithRetry(request);
+        const next = this.getNext(response, args, this.getDatabases);
+        return new response_js_1.FeedResponse(response, next, 'Databases');
+    }
+    async getDatabase(args = {}) {
+        const { dbId = this.dbId, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}`;
+        const request = new Request(url, { method: 'GET' });
+        this.setHeaders(request.headers, headers);
+        const response = await this.fetchWithRetry(request);
+        return new response_js_1.ItemResponse(response);
+    }
+    async getCollections(args = {}) {
+        const { dbId = this.dbId, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls`;
+        const request = new Request(url, { method: 'GET' });
+        this.setHeaders(request.headers, headers);
+        const response = await this.fetchWithRetry(request);
+        const next = this.getNext(response, args, this.getCollections);
+        return new response_js_1.FeedResponse(response, next, 'DocumentCollections');
+    }
+    async getCollection(args = {}) {
+        const { dbId = this.dbId, collId = this.collId, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls/${collId}`;
+        const request = new Request(url, { method: 'GET' });
+        this.setHeaders(request.headers, headers);
+        const response = await this.fetchWithRetry(request);
+        return new response_js_1.ItemResponse(response);
+    }
+    async createCollection(args) {
+        const { dbId = this.dbId, collId = this.collId, indexingPolicy, partitionKey, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls`;
+        const body = JSON.stringify({ id: collId, indexingPolicy, partitionKey });
+        const request = new Request(url, { method: 'POST', body });
+        this.setHeaders(request.headers, headers);
+        request.headers.set('content-type', 'application/json');
+        const response = await this.fetchWithRetry(request);
+        return new response_js_1.ItemResponse(response);
+    }
+    async replaceCollection(args) {
+        const { dbId = this.dbId, collId = this.collId, indexingPolicy, partitionKey, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls/${collId}`;
+        const body = JSON.stringify({ id: collId, indexingPolicy, partitionKey });
+        const request = new Request(url, { method: 'PUT', body });
+        this.setHeaders(request.headers, headers);
+        request.headers.set('content-type', 'application/json');
+        const response = await this.fetchWithRetry(request);
+        return new response_js_1.ItemResponse(response);
+    }
+    async deleteCollection(args = {}) {
+        const { dbId = this.dbId, collId = this.collId, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls/${collId}`;
+        const request = new Request(url, { method: 'DELETE' });
+        this.setHeaders(request.headers, headers);
+        const response = await this.fetchWithRetry(request);
+        return response;
+    }
+    async getDocuments(args) {
+        const { dbId = this.dbId, collId = this.collId, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls/${collId}/docs`;
+        const request = new Request(url, { method: 'GET' });
+        this.setHeaders(request.headers, headers);
+        const response = await this.fetchWithRetry(request);
+        const next = this.getNext(response, args, this.getDocuments);
+        return new response_js_1.FeedResponse(response, next, 'Documents');
+    }
+    async getDocument(args) {
+        const { dbId = this.dbId, collId = this.collId, docId, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls/${collId}/docs/${docId}`;
+        const request = new Request(url, { method: 'GET' });
+        this.setHeaders(request.headers, headers);
+        const response = await this.fetchWithRetry(request);
+        return new response_js_1.ItemResponse(response);
+    }
+    async createDocument(args) {
+        const { dbId = this.dbId, collId = this.collId, document, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls/${collId}/docs`;
+        const body = toBodyInit(document);
+        const request = new Request(url, { method: 'POST', body });
+        this.setHeaders(request.headers, headers);
+        request.headers.set('content-type', 'application/json');
+        const response = await this.fetchWithRetry(request);
+        return new response_js_1.ItemResponse(response);
+    }
+    async replaceDocument(args) {
+        const { dbId = this.dbId, collId = this.collId, docId, document, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls/${collId}/docs/${docId}`;
+        const body = toBodyInit(document);
+        const request = new Request(url, { method: 'PUT', body });
+        this.setHeaders(request.headers, headers);
+        request.headers.set('content-type', 'application/json');
+        const response = await this.fetchWithRetry(request);
+        return new response_js_1.ItemResponse(response);
+    }
+    async deleteDocument(args) {
+        const { dbId = this.dbId, collId = this.collId, docId, ...headers } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls/${collId}/docs/${docId}`;
+        const request = new Request(url, { method: 'DELETE' });
+        this.setHeaders(request.headers, headers);
+        const response = await this.fetchWithRetry(request);
+        return response;
+    }
+    async queryDocuments(args) {
+        const { dbId = this.dbId, collId = this.collId, query, parameters = [], ...headerArgs } = args;
+        (0, util_js_1.assertArg)('dbId', dbId);
+        (0, util_js_1.assertArg)('collId', collId);
+        const headers = Object.assign({
+            enableCrossPartition: this.enableCrossPartitionQueries,
+            enableScan: false,
+            maxItems: -1,
+            populateMetrics: false,
+            isQuery: true
+        }, headerArgs);
+        const url = this.endpoint + (0, util_js_1.uri) `/dbs/${dbId}/colls/${collId}/docs`;
+        const body = JSON.stringify({ query, parameters });
+        const request = new Request(url, { method: 'POST', body });
+        this.setHeaders(request.headers, headers);
+        request.headers.set('content-type', 'application/query+json');
+        const response = await this.fetchWithRetry(request);
+        const next = this.getNext(response, args, this.queryDocuments);
+        return new response_js_1.FeedResponse(response, next, 'Documents');
+    }
+    getNext(response, args, fn) {
+        return () => {
+            const continuation = response.headers.get('x-ms-continuation');
+            if (!continuation) {
+                throw new Error(`Response is not continuable.`);
+            }
+            return fn.call(this, Object.assign({}, args, { continuation }));
+        };
+    }
+    async fetchWithRetry(request, context) {
+        const retryRequest = request.clone();
+        const response = await this.fetch(request);
+        context ??= { attempts: 0, cumulativeWaitMs: 0, request, response };
+        context.attempts++;
+        context.request = retryRequest;
+        context.response = response;
+        const { retry, delayMs } = await this.retryPolicy.shouldRetry(context);
+        if (!retry) {
+            return response;
+        }
+        if (delayMs !== 0) {
+            await new Promise(resolve => setTimeout(resolve, delayMs));
+            context.cumulativeWaitMs += delayMs;
+            this.retries.delayMs += delayMs;
+        }
+        this.retries.count++;
+        return this.fetchWithRetry(retryRequest, context);
+    }
+    async fetch(request) {
+        this.sessions.setRequestSession(request);
+        await this.signer.sign(request);
+        const response = await this.systemFetch(request);
+        this.sessions.readResponseSession(response);
+        const requestCharge = +(response.headers.get('x-ms-request-charge') || 0);
+        this.requestCharges += requestCharge;
+        return response;
+    }
+    setHeaders(headers, args) {
+        headers.set('accept', 'application/json');
+        headers.set('cache-control', 'no-cache');
+        headers.set('x-ms-version', '2018-12-31');
+        if (args.activityId) {
+            headers.set('x-ms-activity-id', args.activityId);
+        }
+        const consistencyLevel = args.consistencyLevel || this.consistencyLevel;
+        headers.set('x-ms-consistency-level', consistencyLevel);
+        if (args.continuation) {
+            headers.set('x-ms-continuation', args.continuation);
+        }
+        if (args.enableScan) {
+            headers.set('x-ms-documentdb-query-enable-scan', 'true');
+        }
+        if (args.ifMatch) {
+            headers.set('if-match', args.ifMatch);
+        }
+        if (args.ifModifiedSince) {
+            headers.set('if-modified-since', args.ifModifiedSince.toUTCString());
+        }
+        if (args.ifNoneMatch) {
+            headers.set('if-none-match', args.ifNoneMatch);
+        }
+        if (args.indexingDirective) {
+            headers.set('x-ms-indexing-directive', args.indexingDirective);
+        }
+        if (args.isQuery) {
+            headers.set('x-ms-documentdb-isquery', args.isQuery.toString());
+        }
+        if (args.isUpsert) {
+            headers.set('x-ms-documentdb-is-upsert', args.isUpsert.toString());
+        }
+        if (args.maxItems) {
+            headers.set('x-ms-max-item-count', args.maxItems.toString(10));
+        }
+        if (args.offerType) {
+            headers.set('x-ms-offer-type', args.offerType);
+        }
+        if (args.offerThroughput) {
+            headers.set('x-ms-offer-throughput', args.offerThroughput.toString());
+        }
+        if (args.populateMetrics) {
+            headers.set('x-ms-documentdb-populatequerymetrics', 'true');
+        }
+        if (args.partitionKey) {
+            headers.set('x-ms-documentdb-partitionkey', (0, util_js_1.escapeNonASCII)(JSON.stringify([args.partitionKey])));
+            if (args.isQuery) {
+                headers.set('x-ms-documentdb-query-enablecrosspartition', 'false');
+            }
+        }
+        else if (args.enableCrossPartition !== undefined && args.isQuery) {
+            headers.set('x-ms-documentdb-query-enablecrosspartition', args.enableCrossPartition.toString());
+        }
+    }
+}
+exports.CosmosClient = CosmosClient;
+function toBodyInit(obj) {
+    if ((typeof obj === 'string' || DataView.prototype.isPrototypeOf(obj),
+        ArrayBuffer.isView(obj) || obj instanceof ReadableStream)) {
+        return obj;
+    }
+    return JSON.stringify(obj);
+}

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client.js"), exports);
+__exportStar(require("./response.js"), exports);
+__exportStar(require("./session.js"), exports);
+__exportStar(require("./signer.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./util.js"), exports);

package/dist/cjs/response.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedResponse = exports.ItemResponse = exports.CosmosResponse = void 0;
+class CosmosResponse {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    get status() {
+        return this.response.status;
+    }
+    get headers() {
+        return this.response.headers;
+    }
+    get body() {
+        return this.response.body;
+    }
+    get activityId() {
+        return this.response.headers.get('x-ms-activity-id');
+    }
+    get etag() {
+        return this.response.headers.get('etag');
+    }
+    get requestCharge() {
+        return parseInt(this.response.headers.get('x-ms-request-charge'));
+    }
+    get raw() {
+        return this.response;
+    }
+}
+exports.CosmosResponse = CosmosResponse;
+class ItemResponse extends CosmosResponse {
+    constructor(response) {
+        super(response);
+    }
+    json() {
+        return this.response.json();
+    }
+}
+exports.ItemResponse = ItemResponse;
+class FeedResponse extends CosmosResponse {
+    next;
+    itemsProperty;
+    constructor(response, next, itemsProperty) {
+        super(response);
+        this.next = next;
+        this.itemsProperty = itemsProperty;
+    }
+    get count() {
+        return parseInt(this.response.headers.get('x-ms-item-count'));
+    }
+    get hasNext() {
+        return this.response.headers.has('x-ms-continuation');
+    }
+    async json() {
+        const data = await this.response.json();
+        return data[this.itemsProperty];
+    }
+}
+exports.FeedResponse = FeedResponse;

package/dist/{retry.d.ts → cjs/retry.d.ts}

@@ -18,4 +18,4 @@ export declare class DefaultRetryPolicy implements RetryPolicy {
     constructor(maxAttempts?: number, maxCumulativeWaitTimeMs?: number, defaultRetryDelayMs?: number);
     shouldRetry(context: RetryContext): Promise<RetryInstruction>;
 }
-export declare const defaultRetryPolicy: DefaultRetryPolicy;
+export declare const defaultRetryPolicy: RetryPolicy;

package/dist/cjs/retry.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRetryPolicy = exports.DefaultRetryPolicy = void 0;
+const session_1 = require("./session");
+class DefaultRetryPolicy {
+    maxAttempts;
+    maxCumulativeWaitTimeMs;
+    defaultRetryDelayMs;
+    constructor(maxAttempts = 10, maxCumulativeWaitTimeMs = 30000, defaultRetryDelayMs = 5000) {
+        this.maxAttempts = maxAttempts;
+        this.maxCumulativeWaitTimeMs = maxCumulativeWaitTimeMs;
+        this.defaultRetryDelayMs = defaultRetryDelayMs;
+    }
+    async shouldRetry(context) {
+        if ((0, session_1.readSessionNotAvailable)(context.response)) {
+            return { retry: true, delayMs: 0 };
+        }
+        if (context.response.status !== 429 ||
+            context.attempts >= this.maxAttempts ||
+            context.cumulativeWaitMs >= this.maxCumulativeWaitTimeMs) {
+            return { retry: false, delayMs: 0 };
+        }
+        const delayMs = +(context.response.headers.get('x-ms-retry-after-ms') ||
+            this.defaultRetryDelayMs);
+        return { retry: true, delayMs };
+    }
+}
+exports.DefaultRetryPolicy = DefaultRetryPolicy;
+exports.defaultRetryPolicy = new DefaultRetryPolicy();

package/dist/cjs/session.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSessionContainer = void 0;
+exports.readSessionNotAvailable = readSessionNotAvailable;
+exports.getCollectionId = getCollectionId;
+const readSessionNotAvailableSubstatus = '1002';
+function readSessionNotAvailable(response) {
+    return (response.status === 404 &&
+        response.headers.get('x-ms-substatus') === readSessionNotAvailableSubstatus);
+}
+function getCollectionId({ url, headers }) {
+    const path = headers.get('x-ms-alt-content-path') ?? new URL(url).pathname.substr(1);
+    const [, dbId, colls, collId] = path.split('/');
+    if (colls !== 'colls' || !collId) {
+        return null;
+    }
+    return { dbId, collId };
+}
+class DefaultSessionContainer {
+    tokens;
+    constructor(tokens = {}) {
+        this.tokens = tokens;
+    }
+    setRequestSession(request) {
+        if (request.headers.get('x-ms-consistency-level') !== 'Session') {
+            return;
+        }
+        const ids = getCollectionId(request);
+        if (!ids) {
+            return;
+        }
+        const token = this.tokens?.[ids.dbId]?.[ids.collId];
+        if (token) {
+            request.headers.set('x-ms-session-token', token);
+        }
+    }
+    readResponseSession(response) {
+        const ids = getCollectionId(response);
+        if (!ids) {
+            return;
+        }
+        if (readSessionNotAvailable(response)) {
+            if (this.tokens[ids.dbId]) {
+                delete this.tokens[ids.dbId][ids.collId];
+            }
+        }
+        const token = response.headers.get('x-ms-session-token');
+        if (!token) {
+            return;
+        }
+        this.tokens[ids.dbId] ??= {};
+        this.tokens[ids.dbId][ids.collId] = token;
+    }
+}
+exports.DefaultSessionContainer = DefaultSessionContainer;

package/dist/cjs/signer.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Signer = void 0;
+exports.getSigner = getSigner;
+const rfc4648_1 = require("rfc4648");
+class Signer {
+    masterkey;
+    encoder = new TextEncoder();
+    constructor(masterkey) {
+        const promiseLike = crypto.subtle.importKey('raw', rfc4648_1.base64.parse(masterkey), { name: 'HMAC', hash: { name: 'SHA-256' } }, false, ['sign']);
+        this.masterkey = Promise.resolve(promiseLike);
+    }
+    async sign(request, date = new Date()) {
+        const key = await this.masterkey;
+        const payload = this.getPayload(request, date);
+        const hashed = await crypto.subtle.sign('HMAC', key, payload);
+        const signature = rfc4648_1.base64.stringify(new Uint8Array(hashed));
+        request.headers.set('authorization', encodeURIComponent(`type=master&ver=1.0&sig=${signature}`));
+        request.headers.set('x-ms-date', date.toUTCString());
+    }
+    getPayload(request, date) {
+        const url = new URL(request.url);
+        const { resourceType, resourceId } = this.pathnameToResource(url.pathname);
+        const method = request.method.toLowerCase();
+        const text = `${method}\n${resourceType}\n${resourceId}\n${date
+            .toUTCString()
+            .toLowerCase()}\n\n`;
+        return this.encoder.encode(text);
+    }
+    pathnameToResource(pathname) {
+        const segments = pathname.split('/');
+        if (segments.length % 2 === 0) {
+            const resourceType = segments[segments.length - 1];
+            const resourceId = segments.slice(1, segments.length - 1).join('/');
+            return { resourceType, resourceId };
+        }
+        const resourceType = segments[segments.length - 2];
+        const resourceId = segments.slice(1, segments.length).join('/');
+        return { resourceType, resourceId };
+    }
+}
+exports.Signer = Signer;
+const signers = {};
+function getSigner(masterKey) {
+    if (!signers[masterKey]) {
+        signers[masterKey] = new Signer(masterKey);
+    }
+    return signers[masterKey];
+}

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/util.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeNonASCII = escapeNonASCII;
+exports.assertArg = assertArg;
+exports.uri = uri;
+exports.parseConnectionString = parseConnectionString;
+function escapeNonASCII(s) {
+    return s.replace(/[\u0080-\uFFFF]/g, m => '\\u' + m.charCodeAt(0).toString(16).padStart(4, '0'));
+}
+function assertArg(name, value) {
+    if (!value) {
+        throw new Error(`${name} is required.`);
+    }
+}
+function uri(strings, ...values) {
+    let s = strings[0];
+    for (let i = 0; i < values.length; i++) {
+        s += encodeURIComponent(values[i]) + strings[i + 1];
+    }
+    return s;
+}
+function parseConnectionString(connString) {
+    const props = {};
+    connString.split(';').forEach(kv => {
+        const pos = kv.indexOf('=');
+        if (pos < 1) {
+            return;
+        }
+        const key = kv.slice(0, pos);
+        const val = kv.slice(pos + 1);
+        if (key && val) {
+            props[key] = val;
+        }
+    });
+    if (!props.AccountEndpoint || !props.AccountKey) {
+        throw new Error('Invalid connection string');
+    }
+    return {
+        endpoint: props.AccountEndpoint,
+        masterKey: props.AccountKey
+    };
+}