@reatomized/convex 0.0.0-stage → 0.1.0

package/dist/browser/sync/protocol.d.ts

@@ -0,0 +1,206 @@
+import type { UserIdentityAttributes } from "convex/server";
+export type { UserIdentityAttributes } from "convex/server";
+import { JSONValue } from "convex/values";
+import { Long } from "../../vendor/long.js";
+/**
+ * Shared schema
+ */
+export declare function u64ToLong(encoded: EncodedU64): U64;
+export declare function longToU64(raw: U64): EncodedU64;
+export declare function parseServerMessage(encoded: EncodedServerMessage): WireServerMessage;
+export declare function encodeClientMessage(message: ClientMessage): EncodedClientMessage;
+type U64 = Long;
+type EncodedU64 = string;
+/**
+ * Unique nonnegative integer identifying a single query.
+ */
+export type QueryId = number;
+export type QuerySetVersion = number;
+export type RequestId = number;
+export type IdentityVersion = number;
+/**
+ * A serialized representation of decisions made during a query's execution.
+ *
+ * A journal is produced when a query function first executes and is re-used
+ * when a query is re-executed.
+ *
+ * Currently this is used to store pagination end cursors to ensure
+ * that pages of paginated queries will always end at the same cursor. This
+ * enables gapless, reactive pagination.
+ *
+ * `null` is used to represent empty journals.
+ * @public
+ */
+export type QueryJournal = string | null;
+/**
+ * Client message schema
+ */
+type Connect = {
+    type: "Connect";
+    sessionId: string;
+    connectionCount: number;
+    lastCloseReason: string | null;
+    maxObservedTimestamp?: TS | undefined;
+    clientTs: number;
+};
+export type AddQuery = {
+    type: "Add";
+    queryId: QueryId;
+    udfPath: string;
+    args: JSONValue[];
+    journal?: QueryJournal | undefined;
+};
+export type RemoveQuery = {
+    type: "Remove";
+    queryId: QueryId;
+};
+export type QuerySetModification = {
+    type: "ModifyQuerySet";
+    baseVersion: QuerySetVersion;
+    newVersion: QuerySetVersion;
+    modifications: (AddQuery | RemoveQuery)[];
+};
+export type MutationRequest = {
+    type: "Mutation";
+    requestId: RequestId;
+    udfPath: string;
+    args: JSONValue[];
+    componentPath?: string | undefined;
+};
+export type ActionRequest = {
+    type: "Action";
+    requestId: RequestId;
+    udfPath: string;
+    args: JSONValue[];
+    componentPath?: string | undefined;
+};
+export type AdminAuthentication = {
+    type: "Authenticate";
+    tokenType: "Admin";
+    value: string;
+    baseVersion: IdentityVersion;
+    impersonating?: UserIdentityAttributes | undefined;
+};
+export type Authenticate = AdminAuthentication | {
+    type: "Authenticate";
+    tokenType: "User";
+    value: string;
+    baseVersion: IdentityVersion;
+} | {
+    type: "Authenticate";
+    tokenType: "None";
+    baseVersion: IdentityVersion;
+};
+export type Event = {
+    type: "Event";
+    eventType: string;
+    event: any;
+};
+export type ClientMessage = Connect | Authenticate | QuerySetModification | MutationRequest | ActionRequest | Event;
+type EncodedConnect = Omit<Connect, "maxObservedTimestamp"> & {
+    maxObservedTimestamp?: EncodedTS | undefined;
+};
+type EncodedClientMessage = EncodedConnect | Authenticate | QuerySetModification | MutationRequest | ActionRequest | Event;
+/**
+ * Server message schema
+ */
+export type TS = U64;
+type EncodedTS = EncodedU64;
+type LogLines = string[];
+export type StateVersion = {
+    querySet: QuerySetVersion;
+    ts: TS;
+    identity: IdentityVersion;
+};
+type EncodedStateVersion = Omit<StateVersion, "ts"> & {
+    ts: EncodedTS;
+};
+type StateModification = {
+    type: "QueryUpdated";
+    queryId: QueryId;
+    value: JSONValue;
+    logLines: LogLines;
+    journal: QueryJournal;
+} | {
+    type: "QueryFailed";
+    queryId: QueryId;
+    errorMessage: string;
+    logLines: LogLines;
+    errorData: JSONValue;
+    journal: QueryJournal;
+} | {
+    type: "QueryRemoved";
+    queryId: QueryId;
+};
+export type Transition = {
+    type: "Transition";
+    startVersion: StateVersion;
+    endVersion: StateVersion;
+    modifications: StateModification[];
+    clientClockSkew?: number;
+    serverTs?: number;
+};
+export type TransitionChunk = {
+    type: "TransitionChunk";
+    chunk: string;
+    partNumber: number;
+    totalParts: number;
+    transitionId: string;
+};
+type MutationSuccess = {
+    type: "MutationResponse";
+    requestId: RequestId;
+    success: true;
+    result: JSONValue;
+    ts: TS;
+    logLines: LogLines;
+};
+type MutationFailed = {
+    type: "MutationResponse";
+    requestId: RequestId;
+    success: false;
+    result: string;
+    logLines: LogLines;
+    errorData?: JSONValue;
+};
+export type MutationResponse = MutationSuccess | MutationFailed;
+type ActionSuccess = {
+    type: "ActionResponse";
+    requestId: RequestId;
+    success: true;
+    result: JSONValue;
+    logLines: LogLines;
+};
+type ActionFailed = {
+    type: "ActionResponse";
+    requestId: RequestId;
+    success: false;
+    result: string;
+    logLines: LogLines;
+    errorData?: JSONValue;
+};
+export type ActionResponse = ActionSuccess | ActionFailed;
+export type AuthError = {
+    type: "AuthError";
+    error: string;
+    baseVersion: IdentityVersion;
+    authUpdateAttempted: boolean;
+};
+type FatalError = {
+    type: "FatalError";
+    error: string;
+};
+type Ping = {
+    type: "Ping";
+};
+export type ServerMessage = Transition | MutationResponse | ActionResponse | FatalError | AuthError;
+export type WireServerMessage = Transition | TransitionChunk | MutationResponse | ActionResponse | FatalError | AuthError | Ping;
+type EncodedTransition = Omit<Transition, "startVersion" | "endVersion"> & {
+    startVersion: EncodedStateVersion;
+    endVersion: EncodedStateVersion;
+};
+type EncodedMutationSuccess = Omit<MutationSuccess, "ts"> & {
+    ts: EncodedTS;
+};
+type EncodedMutationResponse = MutationFailed | EncodedMutationSuccess;
+type EncodedServerMessage = EncodedTransition | TransitionChunk | EncodedMutationResponse | ActionResponse | FatalError | AuthError | Ping;

package/dist/browser/sync/protocol.js

@@ -0,0 +1,75 @@
+import { Base64 } from "convex/values";
+import { Long } from "../../vendor/long.js";
+/**
+ * Shared schema
+ */
+export function u64ToLong(encoded) {
+    const integerBytes = Base64.toByteArray(encoded);
+    return Long.fromBytesLE(Array.from(integerBytes));
+}
+export function longToU64(raw) {
+    const integerBytes = new Uint8Array(raw.toBytesLE());
+    return Base64.fromByteArray(integerBytes);
+}
+export function parseServerMessage(encoded) {
+    switch (encoded.type) {
+        case "FatalError":
+        case "AuthError":
+        case "ActionResponse":
+        case "TransitionChunk":
+        case "Ping": {
+            return { ...encoded };
+        }
+        case "MutationResponse": {
+            if (encoded.success) {
+                return { ...encoded, ts: u64ToLong(encoded.ts) };
+            }
+            else {
+                return { ...encoded };
+            }
+        }
+        case "Transition": {
+            return {
+                ...encoded,
+                startVersion: {
+                    ...encoded.startVersion,
+                    ts: u64ToLong(encoded.startVersion.ts),
+                },
+                endVersion: {
+                    ...encoded.endVersion,
+                    ts: u64ToLong(encoded.endVersion.ts),
+                },
+            };
+        }
+        default: {
+            encoded;
+        }
+    }
+    return undefined;
+}
+export function encodeClientMessage(message) {
+    switch (message.type) {
+        case "Authenticate":
+        case "ModifyQuerySet":
+        case "Mutation":
+        case "Action":
+        case "Event": {
+            return { ...message };
+        }
+        case "Connect": {
+            if (message.maxObservedTimestamp !== undefined) {
+                return {
+                    ...message,
+                    maxObservedTimestamp: longToU64(message.maxObservedTimestamp),
+                };
+            }
+            else {
+                return { ...message, maxObservedTimestamp: undefined };
+            }
+        }
+        default: {
+            message;
+        }
+    }
+    return undefined;
+}

package/dist/browser/sync/session.d.ts

@@ -0,0 +1 @@
+export declare function newSessionId(): string;

package/dist/browser/sync/session.js

@@ -0,0 +1,10 @@
+export function newSessionId() {
+    return uuidv4();
+}
+// From https://stackoverflow.com/a/2117523
+function uuidv4() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0, v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}

package/dist/browser/sync/udf_path_utils.d.ts

@@ -0,0 +1,30 @@
+import { Value } from "convex/values";
+export declare function canonicalizeUdfPath(udfPath: string): string;
+/**
+ * The serialization here is not stable, these strings never make it outside the client.
+ */
+/**
+ * A string representing the name and arguments of a query.
+ *
+ * This is used by the {@link BaseConvexClient}.
+ *
+ * @public
+ */
+export type QueryToken = string & {
+    __queryToken: true;
+};
+/**
+ * A string representing the name and arguments of a paginated query.
+ *
+ * This is a specialized form of QueryToken used for paginated queries.
+ */
+export type PaginatedQueryToken = QueryToken & {
+    __paginatedQueryToken: true;
+};
+export declare function serializePathAndArgs(udfPath: string, args: Record<string, Value>): QueryToken;
+export declare function serializePaginatedPathAndArgs(udfPath: string, args: Record<string, Value>, // args WITHOUT paginationOpts
+options: {
+    initialNumItems: number;
+    id: number;
+}): PaginatedQueryToken;
+export declare function serializedQueryTokenIsPaginated(token: QueryToken | PaginatedQueryToken): token is PaginatedQueryToken;

package/dist/browser/sync/udf_path_utils.js

@@ -0,0 +1,38 @@
+import { convexToJson } from "convex/values";
+export function canonicalizeUdfPath(udfPath) {
+    const pieces = udfPath.split(":");
+    let moduleName;
+    let functionName;
+    if (pieces.length === 1) {
+        moduleName = pieces[0];
+        functionName = "default";
+    }
+    else {
+        moduleName = pieces.slice(0, pieces.length - 1).join(":");
+        functionName = pieces[pieces.length - 1];
+    }
+    if (moduleName.endsWith(".js")) {
+        moduleName = moduleName.slice(0, -3);
+    }
+    return `${moduleName}:${functionName}`;
+}
+export function serializePathAndArgs(udfPath, args) {
+    return JSON.stringify({
+        udfPath: canonicalizeUdfPath(udfPath),
+        args: convexToJson(args),
+    });
+}
+export function serializePaginatedPathAndArgs(udfPath, args, // args WITHOUT paginationOpts
+options) {
+    const { initialNumItems, id } = options;
+    const result = JSON.stringify({
+        type: "paginated",
+        udfPath: canonicalizeUdfPath(udfPath),
+        args: convexToJson(args),
+        options: convexToJson({ initialNumItems, id }),
+    });
+    return result;
+}
+export function serializedQueryTokenIsPaginated(token) {
+    return JSON.parse(token).type === "paginated";
+}

package/dist/common/index.d.ts

@@ -0,0 +1,11 @@
+import type { Value } from "convex/values";
+/**
+ * Validate that the arguments to a Convex function are an object, defaulting
+ * `undefined` to `{}`.
+ */
+export declare function parseArgs(args: Record<string, Value> | undefined): Record<string, Value>;
+export declare function validateDeploymentUrl(deploymentUrl: string): void;
+/**
+ * Check whether a value is a plain old JavaScript object.
+ */
+export declare function isSimpleObject(value: unknown): boolean;

package/dist/common/index.js

@@ -0,0 +1,52 @@
+/**
+ * Validate that the arguments to a Convex function are an object, defaulting
+ * `undefined` to `{}`.
+ */
+export function parseArgs(args) {
+    if (args === undefined) {
+        return {};
+    }
+    if (!isSimpleObject(args)) {
+        throw new Error(`The arguments to a Convex function must be an object. Received: ${args}`);
+    }
+    return args;
+}
+export function validateDeploymentUrl(deploymentUrl) {
+    // Don't use things like `new URL(deploymentUrl).hostname` since these aren't
+    // supported by React Native's JS environment
+    if (typeof deploymentUrl === "undefined") {
+        throw new Error(`Client created with undefined deployment address. If you used an environment variable, check that it's set.`);
+    }
+    if (typeof deploymentUrl !== "string") {
+        throw new Error(`Invalid deployment address: found ${deploymentUrl}".`);
+    }
+    if (!(deploymentUrl.startsWith("http:") || deploymentUrl.startsWith("https:"))) {
+        throw new Error(`Invalid deployment address: Must start with "https://" or "http://". Found "${deploymentUrl}".`);
+    }
+    // Most clients should connect to ".convex.cloud". But we also support localhost and
+    // custom custom. We validate the deployment url is a valid url, which is the most
+    // common failure pattern.
+    try {
+        new URL(deploymentUrl);
+    }
+    catch {
+        throw new Error(`Invalid deployment address: "${deploymentUrl}" is not a valid URL. If you believe this URL is correct, use the \`skipConvexDeploymentUrlCheck\` option to bypass this.`);
+    }
+    // If a user uses .convex.site, this is very likely incorrect.
+    if (deploymentUrl.endsWith(".convex.site")) {
+        throw new Error(`Invalid deployment address: "${deploymentUrl}" ends with .convex.site, which is used for HTTP Actions. Convex deployment URLs typically end with .convex.cloud? If you believe this URL is correct, use the \`skipConvexDeploymentUrlCheck\` option to bypass this.`);
+    }
+}
+/**
+ * Check whether a value is a plain old JavaScript object.
+ */
+export function isSimpleObject(value) {
+    const isObject = typeof value === "object";
+    const prototype = Object.getPrototypeOf(value);
+    const isSimple = prototype === null ||
+        prototype === Object.prototype ||
+        // Objects generated from other contexts (e.g. across Node.js `vm` modules) will not satisfy the previous
+        // conditions but are still simple objects.
+        prototype?.constructor?.name === "Object";
+    return isObject && isSimple;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export declare const version = "1.48.0";

package/dist/index.js

@@ -0,0 +1 @@
+export const version = "1.48.0";

package/dist/vendor/jwt-decode/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+ 
+Copyright (c) 2015 Auth0, Inc. <support@auth0.com> (http://auth0.com)
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/vendor/jwt-decode/index.d.ts

@@ -0,0 +1,23 @@
+export interface JwtDecodeOptions {
+    header?: boolean;
+}
+export interface JwtHeader {
+    typ?: string;
+    alg?: string;
+    kid?: string;
+}
+export interface JwtPayload {
+    iss?: string;
+    sub?: string;
+    aud?: string[] | string;
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    jti?: string;
+}
+export declare class InvalidTokenError extends Error {
+}
+export declare function jwtDecode<T = JwtHeader>(token: string, options: JwtDecodeOptions & {
+    header: true;
+}): T;
+export declare function jwtDecode<T = JwtPayload>(token: string, options?: JwtDecodeOptions): T;

package/dist/vendor/jwt-decode/index.js

@@ -0,0 +1,57 @@
+export class InvalidTokenError extends Error {
+}
+InvalidTokenError.prototype.name = "InvalidTokenError";
+function b64DecodeUnicode(str) {
+    return decodeURIComponent(atob(str).replace(/(.)/g, (_m, p) => {
+        let code = p.charCodeAt(0).toString(16).toUpperCase();
+        if (code.length < 2) {
+            code = "0" + code;
+        }
+        return "%" + code;
+    }));
+}
+function base64UrlDecode(str) {
+    let output = str.replace(/-/g, "+").replace(/_/g, "/");
+    switch (output.length % 4) {
+        case 0:
+            break;
+        case 2:
+            output += "==";
+            break;
+        case 3:
+            output += "=";
+            break;
+        default:
+            throw new Error("base64 string is not of the correct length");
+    }
+    try {
+        return b64DecodeUnicode(output);
+    }
+    catch {
+        return atob(output);
+    }
+}
+export function jwtDecode(token, options) {
+    if (typeof token !== "string") {
+        throw new InvalidTokenError("Invalid token specified: must be a string");
+    }
+    options ||= {};
+    const pos = options.header === true ? 0 : 1;
+    const part = token.split(".")[pos];
+    if (typeof part !== "string") {
+        throw new InvalidTokenError(`Invalid token specified: missing part #${pos + 1}`);
+    }
+    let decoded;
+    try {
+        decoded = base64UrlDecode(part);
+    }
+    catch (e) {
+        throw new InvalidTokenError(`Invalid token specified: invalid base64 for part #${pos + 1} (${e.message})`);
+    }
+    try {
+        return JSON.parse(decoded);
+    }
+    catch (e) {
+        throw new InvalidTokenError(`Invalid token specified: invalid json for part #${pos + 1} (${e.message})`);
+    }
+}

package/dist/vendor/long.d.ts

@@ -0,0 +1,16 @@
+export declare class Long {
+    low: number;
+    high: number;
+    __isUnsignedLong__: boolean;
+    static isLong(obj: Long): boolean;
+    constructor(low: number, high: number);
+    static fromBytesLE(bytes: number[]): Long;
+    toBytesLE(): number[];
+    static fromNumber(value: number): Long;
+    toString(): string;
+    equals(other: Long): boolean;
+    notEquals(other: Long): boolean;
+    comp(other: Long): 0 | 1 | -1;
+    lessThanOrEqual(other: Long): boolean;
+    static fromValue(val: any): Long;
+}