@vandenberghinc/volt 1.2.2 → 1.2.4

package/backend/dist/cjs/backend/src/database/collection.d.ts

@@ -159,6 +159,23 @@ export declare class Collection<Data extends mongodb.Document = mongodb.Document
       * - Plain object without '$' keys → NOT valid for updateOne/findOneAndUpdate.
       */
     private _is_operator_update_or_pipeline;
+    private _index_key_signature;
+    private _keys_equal;
+    private _normalize_index_opts;
+    /**
+     * 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.
+     */
+    private _drop_non_init_indexes;
+    /**
+     * Creates indexes on collections.
+     *
+     * @note When transaction mode is enabled, the session option will not be used.
+     *
+     * @param opts The index create options.
+     */
+    private _create_index;
     /**
      * Initialize the collection, creating indexes and setting up TTL if needed.
      * @returns The initialized collection instance.
@@ -215,16 +232,6 @@ export declare class Collection<Data extends mongodb.Document = mongodb.Document
      * @docs
      */
     has_index(index: string): Promise<boolean>;
-    /**
-     * Creates indexes on collections.
-     *
-     * @note When transaction mode is enabled, the session option will not be used.
-     *
-     * @param opts The index create options.
-     *
-     * @docs
-     */
-    create_index(opts: string | Collection.IndexOpts): Promise<string>;
     /**
      * Standalone helper: merge `source` into `target` for missing keys only.
      * Clones assigned nested objects/arrays/dates once (when `clone` is true).

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

@@ -462,6 +462,293 @@ 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) {
+    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) {
+    let key;
+    let keys;
+    let options;
+    let unique;
+    let sparse;
+    let forced = false;
+    if (typeof opts === "string") {
+      key = opts;
+      unique = void 0;
+      sparse = void 0;
+    } else {
+      ({ key, keys, forced = false } = opts);
+      const user_options = opts.options;
+      options = user_options ? { ...user_options } : void 0;
+      if (opts.unique != null && options?.unique != null && opts.unique !== options.unique) {
+        throw new import_errors.InvalidUsageError({
+          message: `Encountered different values for attribute 'unique': ${opts.unique} and 'options.unique': ${options.unique}.`,
+          reason: "invalid_unique_option"
+        });
+      }
+      unique = opts.unique ?? options?.unique;
+      if (opts.sparse != null && options?.sparse != null && opts.sparse !== options.sparse) {
+        throw new import_errors.InvalidUsageError({
+          message: `Encountered different values for attribute 'sparse': ${opts.sparse} and 'options.sparse': ${options.sparse}.`,
+          reason: "invalid_sparse_option"
+        });
+      }
+      sparse = opts.sparse ?? options?.sparse;
+    }
+    if (unique != null) {
+      options = options || {};
+      options.unique = unique;
+    }
+    if (sparse != null) {
+      options = options || {};
+      options.sparse = sparse;
+    }
+    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 import_errors.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();
+    const desired = /* @__PURE__ */ 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));
+    }
+    const protected_names = /* @__PURE__ */ new Set(["_id_"]);
+    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;
+      }
+      if (options?.name) {
+        try {
+          await this._col.dropIndex(options.name);
+        } catch (err) {
+          if (err?.codeName !== "IndexNotFound")
+            throw err;
+        }
+        return;
+      }
+      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.
   // -------------------------------------------------------------------
@@ -524,10 +811,11 @@ class Collection {
           this.db.server.log(3, "Setting up TTL index for collection: " + this.name);
           await this._setup_ttl();
         }
+        await this._drop_non_init_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);
           }
         }
       } else {
@@ -631,131 +919,6 @@ class Collection {
     this.assert_not_transaction_based();
     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) {
-    this.assert_not_transaction_based();
-    if (!this.initialized) {
-      await this.init();
-    }
-    this.assert_init();
-    let key;
-    let keys;
-    let options;
-    let unique;
-    let sparse;
-    let forced = false;
-    if (typeof opts === "string") {
-      key = opts;
-      unique = void 0;
-      sparse = void 0;
-    } else {
-      ({ key, keys, forced = false } = opts);
-      const options2 = opts.options;
-      if (opts.unique != null && options2?.unique != null && opts.unique !== options2.unique) {
-        throw new import_errors.InvalidUsageError({
-          message: `Encountered different values for attribute 'unique': ${opts.unique} and 'options.unique': ${options2.unique}.`,
-          reason: "invalid_unique_option"
-        });
-      }
-      unique = opts.unique ?? options2?.unique;
-      if (opts.sparse != null && options2?.sparse != null && opts.sparse !== options2.sparse) {
-        throw new import_errors.InvalidUsageError({
-          message: `Encountered different values for attribute 'sparse': ${opts.sparse} and 'options.sparse': ${options2.sparse}.`,
-          reason: "invalid_sparse_option"
-        });
-      }
-      sparse = opts.sparse ?? options2?.sparse;
-    }
-    if (unique) {
-      options = options || {};
-      options.unique = unique;
-    }
-    if (sparse) {
-      options = options || {};
-      options.sparse = sparse;
-    }
-    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 import_errors.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;
-          const as = new Map(a);
-          for (const [kk, vv] of b) {
-            if (as.get(kk) !== vv)
-              return false;
-          }
-          return true;
-        });
-        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 {
-          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) {
-        throw new Error(`Failed to create index on collection "${this.name}": ${err}`, { cause: 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 });
-    }
-  }
   /**
    * Standalone helper: merge `source` into `target` for missing keys only.
    * Clones assigned nested objects/arrays/dates once (when `clone` is true).

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

@@ -123,7 +123,8 @@ async function list_all_stripe_products(client) {
   for (; ; ) {
     const page = await (0, import_utils.stripe_api_call)(() => client.products.list({
       limit: stripe_list_page_size,
-      starting_after
+      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) {
@@ -239,7 +240,8 @@ async function create_stripe_product(client, server, product) {
     images: product.images,
     metadata: {
       [app_product_id_metadata_key]: product.id
-    }
+    },
+    expand: ["default_price"]
   }, { idempotencyKey: (0, import_utils.generate_random_idempotency_key)(`create_product_${product.id}`) }), { operation: "products.create", app_product_id: product.id });
 }
 async function update_stripe_product_if_needed(client, server, stripe_product, product) {
@@ -255,11 +257,24 @@ async function update_stripe_product_if_needed(client, server, stripe_product, p
     name: product.name,
     description: product.description,
     tax_code: product.tax_code,
-    images: product.images
+    images: product.images,
+    expand: ["default_price"]
   }, { idempotencyKey: (0, import_utils.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 });
 }
-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) {
+  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 (!default_price_id) {
+    const fetched = await (0, import_utils.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 (default_price_id === default_price.id || 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}'`);
@@ -526,7 +541,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/backend/dist/cjs/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.
      *