@vandenberghinc/volt 1.2.3 → 1.2.4

package/frontend/dist/backend/src/database/collection.js

@@ -492,6 +492,314 @@ export class Collection {
     _is_operator_update_or_pipeline(operation) {
         return Array.isArray(operation) || (operation && typeof operation === "object" && Object.keys(operation).some(k => k[0] === "$"));
     }
+    _index_key_signature(keys) {
+        // Preserve order (Mongo treats order as significant for compound indexes)
+        return Object.entries(keys).map(([k, v]) => `${k}:${v}`).join("|");
+    }
+    _keys_equal(a, b) {
+        const aEnt = Object.entries(a);
+        const bEnt = Object.entries(b);
+        if (aEnt.length !== bEnt.length)
+            return false;
+        for (let i = 0; i < aEnt.length; i++) {
+            const [ak, av] = aEnt[i];
+            const [bk, bv] = bEnt[i];
+            if (ak !== bk || av !== bv)
+                return false;
+        }
+        return true;
+    }
+    _normalize_index_opts(opts) {
+        // ---- Normalize inputs ----
+        let key;
+        let keys;
+        let options;
+        let unique;
+        let sparse;
+        let forced = false;
+        if (typeof opts === "string") {
+            key = opts;
+            unique = undefined;
+            sparse = undefined;
+        }
+        else {
+            ({ key, keys, forced = false } = opts);
+            const user_options = opts.options;
+            options = user_options ? { ...user_options } : undefined;
+            // Conflict guard between `unique` and `options.unique`
+            if (opts.unique != null && options?.unique != null && opts.unique !== options.unique) {
+                throw new InvalidUsageError({
+                    message: `Encountered different values for attribute 'unique': ${opts.unique} and 'options.unique': ${options.unique}.`,
+                    reason: "invalid_unique_option",
+                });
+            }
+            unique = opts.unique ?? options?.unique;
+            // Conflict guard between `sparse` and `options.sparse`
+            if (opts.sparse != null && options?.sparse != null && opts.sparse !== options.sparse) {
+                throw new InvalidUsageError({
+                    message: `Encountered different values for attribute 'sparse': ${opts.sparse} and 'options.sparse': ${options.sparse}.`,
+                    reason: "invalid_sparse_option",
+                });
+            }
+            sparse = opts.sparse ?? options?.sparse;
+        }
+        // Ensure `unique`/`sparse` are reflected in `options`
+        if (unique != null) {
+            options = options || {};
+            options.unique = unique;
+        }
+        if (sparse != null) {
+            options = options || {};
+            options.sparse = sparse;
+        }
+        // ---- Build keys object (same rules everywhere) ----
+        let keys_obj;
+        if (key) {
+            keys_obj = { [key]: 1 };
+        }
+        else if (Array.isArray(keys) && keys.length > 0) {
+            keys_obj = {};
+            for (const k of keys)
+                keys_obj[k] = 1;
+        }
+        else if (keys != null && typeof keys === "object") {
+            keys_obj = keys;
+        }
+        else {
+            throw new InvalidUsageError({
+                message: "Define one of the following parameters: [key, keys].",
+                reason: "invalid_index_definition",
+            });
+        }
+        return { keys_obj, options, forced };
+    }
+    /**
+     * Drop all indexes that are NOT part of this._init_indexes, excluding _id_ (and TTL index if enabled).
+     *
+     * @note We match by key pattern rather than name because names can differ.
+     */
+    async _drop_non_init_indexes() {
+        this.assert_not_transaction_based();
+        this.assert_init();
+        const existing = await this._col.listIndexes().toArray();
+        // Desired signatures (same parsing as create_index)
+        const desired = new Set();
+        for (const item of (this._init_indexes ?? [])) {
+            const { keys_obj } = this._normalize_index_opts(item);
+            desired.add(this._index_key_signature(keys_obj));
+        }
+        // Always keep _id_
+        const protected_names = new Set(["_id_"]);
+        // Keep TTL index if TTL is enabled (managed by _setup_ttl)
+        const keep_ttl = this.ttl_enabled;
+        const ttl_sig = this._index_key_signature({ __ttl_timestamp: 1 });
+        for (const ix of existing) {
+            const name = ix?.name;
+            if (!name)
+                continue;
+            if (protected_names.has(name))
+                continue;
+            const keyObj = ix.key;
+            if (!keyObj)
+                continue;
+            const sig = this._index_key_signature(keyObj);
+            if (desired.has(sig))
+                continue;
+            if (keep_ttl && sig === ttl_sig)
+                continue;
+            try {
+                this.db.server.log(3, `Dropping stale index "${name}" on collection: ${this.name}`);
+                await this._col.dropIndex(name);
+            }
+            catch (err) {
+                if (err?.codeName !== "IndexNotFound")
+                    throw err;
+            }
+        }
+    }
+    /**
+     * Creates indexes on collections.
+     *
+     * @note When transaction mode is enabled, the session option will not be used.
+     *
+     * @param opts The index create options.
+     */
+    async _create_index(opts) {
+        this.assert_not_transaction_based();
+        if (!this.initialized) {
+            await this.init();
+        }
+        this.assert_init();
+        const { keys_obj, options, forced } = this._normalize_index_opts(opts);
+        const drop_index = async () => {
+            const existing = await this._col.listIndexes().toArray();
+            const match = existing.find(ix => {
+                const ix_key = ix?.key;
+                if (!ix_key)
+                    return false;
+                return this._keys_equal(ix_key, keys_obj);
+            });
+            if (match?.name) {
+                try {
+                    await this._col.dropIndex(match.name);
+                }
+                catch (err) {
+                    if (err?.codeName !== "IndexNotFound")
+                        throw err;
+                }
+                return;
+            }
+            // fallback: name provided in options
+            if (options?.name) {
+                try {
+                    await this._col.dropIndex(options.name);
+                }
+                catch (err) {
+                    if (err?.codeName !== "IndexNotFound")
+                        throw err;
+                }
+                return;
+            }
+            // last resort synthesized (may not match Mongo’s generated name for compound cases)
+            const synthesized = Object.entries(keys_obj).map(([k, v]) => `${k}_${v}`).join("_");
+            try {
+                await this._col.dropIndex(synthesized);
+            }
+            catch (err) {
+                if (err?.codeName !== "IndexNotFound")
+                    throw err;
+            }
+        };
+        try {
+            try {
+                return await this._col.createIndex(keys_obj, options);
+            }
+            catch (err) {
+                if (forced && err && typeof err === "object" && err.codeName === "IndexKeySpecsConflict") {
+                    await drop_index();
+                    return await this._col.createIndex(keys_obj, options);
+                }
+                throw err;
+            }
+        }
+        catch (err) {
+            throw new Error(`Failed to create index on collection "${this.name}": ${err}`, { cause: err });
+        }
+    }
+    // async create_index(opts: string | Collection.IndexOpts): Promise<string> {
+    //     // Not supported on transaction-based collections.
+    //     this.assert_not_transaction_based();
+    //     // Ensure initialized
+    //     if (!this.initialized) { await this.init(); } this.assert_init();
+    //     // ---- Normalize inputs ----
+    //     let key: string | undefined;
+    //     let keys: string[] | Record<string, number> | undefined;
+    //     let options: mongodb.CreateIndexesOptions | undefined;
+    //     let unique: boolean | undefined;
+    //     let sparse: boolean | undefined;
+    //     let forced = false;
+    //     if (typeof opts === "string") {
+    //         key = opts;
+    //         unique = undefined;
+    //         sparse = undefined;
+    //     } else {
+    //         ({ key, keys, forced = false } = opts);
+    //         const options = opts.options as unknown as undefined | mongodb.CreateIndexesOptions;
+    //         // Conflict guard between `unique` and `options.unique`
+    //         if (opts.unique != null && options?.unique != null && opts.unique !== options.unique) {
+    //             throw new InvalidUsageError({
+    //                 message: `Encountered different values for attribute 'unique': ${opts.unique} and 'options.unique': ${options.unique}.`,
+    //                 reason: "invalid_unique_option",
+    //             });
+    //         }
+    //         unique = opts.unique ?? options?.unique;
+    //         // Conflict guard between `sparse` and `options.sparse`
+    //         if (opts.sparse != null && options?.sparse != null && opts.sparse !== options.sparse) {
+    //             throw new InvalidUsageError({
+    //                 message: `Encountered different values for attribute 'sparse': ${opts.sparse} and 'options.sparse': ${options.sparse}.`,
+    //                 reason: "invalid_sparse_option",
+    //             });
+    //         }
+    //         sparse = opts.sparse ?? options?.sparse;
+    //     }
+    //     // Ensure `unique` in options when provided
+    //     if (unique) {
+    //         options = options || {};
+    //         options.unique = unique;
+    //     }
+    //     // Ensure `sparse` in options when provided
+    //     if (sparse) {
+    //         options = options || {};
+    //         options.sparse = sparse;
+    //     }
+    //     // Build keys object
+    //     let keys_obj: Record<string, number>;
+    //     if (key) {
+    //         keys_obj = { [key]: 1 };
+    //     } else if (Array.isArray(keys) && keys.length > 0) {
+    //         keys_obj = {};
+    //         for (const k of keys) keys_obj[k] = 1;
+    //     } else if (keys != null && typeof keys === "object") {
+    //         keys_obj = keys as Record<string, number>;
+    //     } else {
+    //         throw new InvalidUsageError({
+    //             message: "Define one of the following parameters: [key, keys].",
+    //             reason: "invalid_index_definition",
+    //         });
+    //     }
+    //     const drop_index = async () => {
+    //         try {
+    //             const existing = await this._col.listIndexes().toArray();
+    //             const match = existing.find(ix => {
+    //                 const ix_key = ix?.key as Record<string, number> | undefined;
+    //                 if (!ix_key) return false;
+    //                 const a = Object.entries(ix_key);
+    //                 const b = Object.entries(keys_obj);
+    //                 if (a.length !== b.length) return false;
+    //                 // exact key-value equality (order-insensitive)
+    //                 const as = new Map(a);
+    //                 for (const [kk, vv] of b) {
+    //                     if (as.get(kk) !== vv) return false;
+    //                 }
+    //                 return true;
+    //             });
+    //             // Prefer matched key's real name
+    //             if (match?.name) {
+    //                 try { await this._col.dropIndex(match.name); }
+    //                 catch (err: any) { if (err?.codeName !== "IndexNotFound") throw err; }
+    //             } else if (options?.name) {
+    //                 try { await this._col.dropIndex(options.name); }
+    //                 catch (err: any) { if (err?.codeName !== "IndexNotFound") throw err; }
+    //             } else {
+    //                 // last-resort synthesized name (simple cases)
+    //                 const synthesized = Object.entries(keys_obj).map(([k, v]) => `${k}_${v}`).join("_");
+    //                 try { await this._col.dropIndex(synthesized); }
+    //                 catch (err: any) { if (err?.codeName !== "IndexNotFound") throw err; }
+    //             }
+    //         } catch (err) {
+    //             // If listIndexes itself fails for some reason, do not hide the error
+    //             throw new Error(`Failed to create index on collection "${this.name}": ${err}`, { cause: err });
+    //         }
+    //     }
+    //     try {
+    //         // Create (or re-create)
+    //         try {
+    //             return await this._col.createIndex(keys_obj, options);
+    //         }
+    //         // Retry once on IndexKeySpecsConflict when forced=true
+    //         catch (err) {
+    //             if (forced && err && typeof err === "object" && (
+    //                 (err as any).codeName === "IndexKeySpecsConflict"
+    //             )) {
+    //                 await drop_index();
+    //                 return await this._col.createIndex(keys_obj, options);
+    //             }
+    //             throw err;
+    //         }
+    //     } catch (err) {
+    //         throw new Error(`Failed to create index on collection "${this.name}": ${err}`, { cause: err });
+    //     }
+    // }
     // -------------------------------------------------------------------
     // Public methods.
     // -------------------------------------------------------------------
@@ -567,11 +875,13 @@ export class Collection {
                     this.db.server.log(3, "Setting up TTL index for collection: " + this.name);
                     await this._setup_ttl();
                 }
+                // Drop indexes that are not in this._init_indexes (keep _id_ + TTL).
+                await this._drop_non_init_indexes();
                 // Create indexes.
                 if (this._init_indexes?.length) {
                     for (const item of this._init_indexes) {
                         this.db.server.log(3, "Creating index " + JSON.stringify(item) + " on collection: " + this.name);
-                        await this.create_index(item);
+                        await this._create_index(item);
                     }
                 }
             }
@@ -686,157 +996,6 @@ export class Collection {
         // No need to pass session obj here.
         return (await this._col.listIndexes().toArray()).some(x => x.name === index);
     }
-    /**
-     * Creates indexes on collections.
-     *
-     * @note When transaction mode is enabled, the session option will not be used.
-     *
-     * @param opts The index create options.
-     *
-     * @docs
-     */
-    async create_index(opts) {
-        // Not supported on transaction-based collections.
-        this.assert_not_transaction_based();
-        // Ensure initialized
-        if (!this.initialized) {
-            await this.init();
-        }
-        this.assert_init();
-        // ---- Normalize inputs ----
-        let key;
-        let keys;
-        let options;
-        let unique;
-        let sparse;
-        let forced = false;
-        if (typeof opts === "string") {
-            key = opts;
-            unique = undefined;
-            sparse = undefined;
-        }
-        else {
-            ({ key, keys, forced = false } = opts);
-            const options = opts.options;
-            // Conflict guard between `unique` and `options.unique`
-            if (opts.unique != null && options?.unique != null && opts.unique !== options.unique) {
-                throw new InvalidUsageError({
-                    message: `Encountered different values for attribute 'unique': ${opts.unique} and 'options.unique': ${options.unique}.`,
-                    reason: "invalid_unique_option",
-                });
-            }
-            unique = opts.unique ?? options?.unique;
-            // Conflict guard between `sparse` and `options.sparse`
-            if (opts.sparse != null && options?.sparse != null && opts.sparse !== options.sparse) {
-                throw new InvalidUsageError({
-                    message: `Encountered different values for attribute 'sparse': ${opts.sparse} and 'options.sparse': ${options.sparse}.`,
-                    reason: "invalid_sparse_option",
-                });
-            }
-            sparse = opts.sparse ?? options?.sparse;
-        }
-        // Ensure `unique` in options when provided
-        if (unique) {
-            options = options || {};
-            options.unique = unique;
-        }
-        // Ensure `sparse` in options when provided
-        if (sparse) {
-            options = options || {};
-            options.sparse = sparse;
-        }
-        // Build keys object
-        let keys_obj;
-        if (key) {
-            keys_obj = { [key]: 1 };
-        }
-        else if (Array.isArray(keys) && keys.length > 0) {
-            keys_obj = {};
-            for (const k of keys)
-                keys_obj[k] = 1;
-        }
-        else if (keys != null && typeof keys === "object") {
-            keys_obj = keys;
-        }
-        else {
-            throw new InvalidUsageError({
-                message: "Define one of the following parameters: [key, keys].",
-                reason: "invalid_index_definition",
-            });
-        }
-        const drop_index = async () => {
-            try {
-                const existing = await this._col.listIndexes().toArray();
-                const match = existing.find(ix => {
-                    const ix_key = ix?.key;
-                    if (!ix_key)
-                        return false;
-                    const a = Object.entries(ix_key);
-                    const b = Object.entries(keys_obj);
-                    if (a.length !== b.length)
-                        return false;
-                    // exact key-value equality (order-insensitive)
-                    const as = new Map(a);
-                    for (const [kk, vv] of b) {
-                        if (as.get(kk) !== vv)
-                            return false;
-                    }
-                    return true;
-                });
-                // Prefer matched key's real name
-                if (match?.name) {
-                    try {
-                        await this._col.dropIndex(match.name);
-                    }
-                    catch (err) {
-                        if (err?.codeName !== "IndexNotFound")
-                            throw err;
-                    }
-                }
-                else if (options?.name) {
-                    try {
-                        await this._col.dropIndex(options.name);
-                    }
-                    catch (err) {
-                        if (err?.codeName !== "IndexNotFound")
-                            throw err;
-                    }
-                }
-                else {
-                    // last-resort synthesized name (simple cases)
-                    const synthesized = Object.entries(keys_obj).map(([k, v]) => `${k}_${v}`).join("_");
-                    try {
-                        await this._col.dropIndex(synthesized);
-                    }
-                    catch (err) {
-                        if (err?.codeName !== "IndexNotFound")
-                            throw err;
-                    }
-                }
-            }
-            catch (err) {
-                // If listIndexes itself fails for some reason, do not hide the error
-                throw new Error(`Failed to create index on collection "${this.name}": ${err}`, { cause: err });
-            }
-        };
-        try {
-            // Create (or re-create)
-            try {
-                return await this._col.createIndex(keys_obj, options);
-            }
-            // Retry once on IndexKeySpecsConflict when forced=true
-            catch (err) {
-                if (forced && err && typeof err === "object" && (err.codeName === "IndexKeySpecsConflict")) {
-                    await drop_index();
-                    return await this._col.createIndex(keys_obj, options);
-                }
-                throw err;
-            }
-        }
-        catch (err) {
-            throw new Error(`Failed to create index on collection "${this.name}": ${err}`, { cause: err });
-        }
-    }
     /**
      * Standalone helper: merge `source` into `target` for missing keys only.
      * Clones assigned nested objects/arrays/dates once (when `clone` is true).

package/frontend/dist/backend/src/payments/stripe/products.js

@@ -224,6 +224,7 @@ async function list_all_stripe_products(client) {
         const page = await stripe_api_call(() => client.products.list({
             limit: stripe_list_page_size,
             starting_after,
+            expand: ["data.default_price"],
         }), { operation: "products.list_all", starting_after });
         all_products.push(...page.data);
         if (!page.has_more || page.data.length === 0) {
@@ -408,6 +409,7 @@ async function create_stripe_product(client, server, product) {
         metadata: {
             [app_product_id_metadata_key]: product.id,
         },
+        expand: ["default_price"],
     }, { idempotencyKey: generate_random_idempotency_key(`create_product_${product.id}`) }), { operation: "products.create", app_product_id: product.id });
 }
 /**
@@ -433,13 +435,32 @@ async function update_stripe_product_if_needed(client, server, stripe_product, p
         description: product.description,
         tax_code: product.tax_code,
         images: product.images,
+        expand: ["default_price"],
     }, { idempotencyKey: generate_random_idempotency_key(`update_product_${product.id}_${stripe_product.id}`) }), { operation: "products.update", app_product_id: product.id, stripe_product_id: stripe_product.id });
 }
 /**
  * Update default price on a stripe product if needed.
  */
-async function update_stripe_product_default_price_if_needed(client, server, stripe_product, default_price) {
-    if (stripe_product.default_price === default_price.id) {
+async function update_stripe_product_default_price_if_needed(client, server, stripe_product, default_price, other_plans_from_parent_subscription) {
+    // Extract default price.
+    let default_price_id = null;
+    if (typeof stripe_product.default_price === "string") {
+        default_price_id = stripe_product.default_price;
+    }
+    else if (stripe_product.default_price && typeof stripe_product.default_price === "object") {
+        default_price_id = stripe_product.default_price.id;
+    }
+    // If its still undefined, fetch the product to get the default_price expanded (this should be rare since we expand it on list/create/update).
+    if (!default_price_id) {
+        const fetched = await stripe_api_call(() => client.products.retrieve(stripe_product.id, {
+            expand: ["default_price"],
+        }), { operation: "products.retrieve_for_default_price", stripe_product_id: stripe_product.id });
+        default_price_id = typeof fetched.default_price === "string" ? fetched.default_price : fetched.default_price?.id ?? null;
+    }
+    // If the default price is already correct, do nothing.
+    if (default_price_id === default_price.id
+        // For subscription products, the default_price may be shared across multiple plans, so we also check if any other plan from the same subscription is using the price. If so, we should not update the default_price since it would affect those plans as well.
+        || other_plans_from_parent_subscription?.some((plan) => plan.stripe_price_id === default_price_id)) {
         return;
     }
     server.log(0, `Updating default price for Stripe product '${stripe_product.id}' to price '${default_price.id}'`);
@@ -756,7 +777,7 @@ async function initialize_product(client, server, product, stripe_products_by_ap
                 const updated_prices = [...active_prices, stripe_price];
                 active_prices_by_stripe_product_id.set(stripe_product.id, updated_prices);
             }
-            await update_stripe_product_default_price_if_needed(client, server, stripe_product, stripe_price);
+            await update_stripe_product_default_price_if_needed(client, server, stripe_product, stripe_price, initialized_plans);
             initialized_plans.push({
                 ...plan,
                 type: "subscription_plan",

package/frontend/dist/backend/src/stream.d.ts

@@ -362,17 +362,69 @@ export declare class Stream {
      */
     remove_headers(...names: string[]): this;
     /**
-     * Set a cookie that will be sent with the response.
+     * Set a cookie to be sent with the response.
+     *
+     * Accepts either:
+     * 1) a pre-built cookie header string (used as-is, no validation), or
+     * 2) a structured object describing the cookie, from which a standards-compliant
+     *    cookie string will be generated.
+     *
+     * If a cookie with the same name already exists in the pending response list,
+     * it will be replaced.
+     *
+     * @warning Cookies are only included in the response when using `send()`,
+     *          `success()` or `error()`.
      *
-     * @warning Will only be added to the response when the user uses `send()`, `success()` or `error()`.
-     * @param cookie The cookie string.
      * @example
      * ```ts
-     * stream.set_cookie("MyCookie=Hello World;");
+     * stream.set_cookie("sid=abc123; Path=/; SameSite=Lax; Secure; HttpOnly");
+     *
+     * stream.set_cookie({
+     *   name: "sid",
+     *   value: session_id,
+     *   http_only: true,
+     *   secure: true,
+     *   same_site: "Lax",
+     *   path: "/",
+     *   max_age: 60 * 60 * 24 * 14,
+     * });
      * ```
-     * @docs
      */
-    set_cookie(cookie: string): this;
+    set_cookie(cookie: string | {
+        /** Cookie name (required). */
+        name: string;
+        /** Cookie value. Will be URI-encoded. Defaults to empty string. */
+        value?: string | number | boolean | null;
+        /** Cookie path attribute. Defaults to "/". */
+        path?: string;
+        /** Cookie domain attribute. */
+        domain?: string;
+        /** Max-Age in seconds. Must be a finite number. */
+        max_age?: number;
+        /** Expiration date (Date or preformatted HTTP date string). */
+        expires?: Date | string;
+        /** Adds the Secure attribute (HTTPS only). */
+        secure?: boolean;
+        /** Adds the HttpOnly attribute (not accessible to JS). */
+        http_only?: boolean;
+        /**
+         * SameSite attribute.
+         * Use "Lax" for most session cookies.
+         * Use "None" only together with `secure: true`.
+         */
+        same_site?: "Strict" | "Lax" | "None";
+        /**
+         * Cookie name prefix.
+         * "__Host-" requires: secure=true, path="/", and no domain.
+         * "__Secure-" requires: secure=true.
+         */
+        prefix?: "__Host-" | "__Secure-";
+        /**
+         * Additional raw attributes appended verbatim.
+         * Example: ["Priority=High"]
+         */
+        extra?: string[];
+    }): this;
     /**
      * Set cookies that will be sent with the response.
      *