@malloy-publisher/server 0.0.198 → 0.0.199

package/src/package_load/protocol.ts

@@ -0,0 +1,336 @@
+/**
+ * Wire protocol between the main thread (`PackageLoadPool`) and a
+ * package-load worker thread.
+ *
+ * Boundary
+ * --------
+ * The worker performs the **CPU-bound bulk of `Package.create`** off
+ * the main event loop:
+ *
+ *   1. Read `publisher.config.json` (cheap, but already on the worker
+ *      side of the boundary so the main thread isn't blocked).
+ *   2. Compile every `.malloy` / `.malloynb` (the Malloy parser,
+ *      type-checker, and IR-builder — the dominant CPU cost).
+ *   3. Return a structured-clonable POJO carrying every `modelDef`,
+ *      `sourceInfos`, dataStyles, etc. that the main thread needs to
+ *      reconstitute a live `Package`.
+ *
+ * Embedded database probing (`.parquet` / `.csv` schema + row count)
+ * stays on the main thread — it reuses the package's existing DuckDB
+ * connection (PR #772) and the probe queries are async-IO-bound, not
+ * CPU-bound. Keeping all native-DB handles on the main thread also
+ * sidesteps Bun crash 0x20131 where duckdb-native cannot be loaded
+ * into more than one isolate of the same process.
+ *
+ * The main thread reconstitutes by:
+ *   - Building a fresh `MalloyConfig` against its own connection pool
+ *     (live native handles can't cross the worker boundary).
+ *   - Lazy-hydrating each model's `ModelMaterializer` from `modelDef`
+ *     via `Runtime._loadModelFromModelDef` on first query — NO
+ *     recompile. This is what closes the loop on PR #767's original
+ *     "first-query recompile on main thread" gap.
+ *
+ * Per-model compile failures are returned in-band on
+ * `SerializedModel.compilationError` so a single bad model doesn't
+ * abort the rest of the package load. The main thread decides
+ * whether/when to surface as a fatal `Package.create` error (today
+ * it throws on the first error; `Package.reloadAllModels` keeps the
+ * failed models as placeholders in the package's model map).
+ *
+ * Whole-package failures (manifest missing, FS errors, worker
+ * crashes) come back as `LoadPackageError`. The pool main-thread
+ * half (`PackageLoadPool.loadPackage`) rejects with a deserialised
+ * Error; `Package.loadViaWorker` then rewraps any non-compile
+ * failure as `ServiceUnavailableError` so the HTTP layer responds
+ * 503 (transient, retryable) — there is no in-process fallback.
+ *
+ * Direction summary
+ * -----------------
+ *   main  ──▶ worker:  LoadPackageRequest         (start)
+ *   worker ──▶ main:   LoadPackageResult          (success)
+ *   worker ──▶ main:   LoadPackageError           (whole-package failure)
+ *
+ *   worker ──▶ main:   ConnectionMetadataRequest  (proxy non-duckdb lookups)
+ *   worker ──▶ main:   SchemaForTablesRequest     (proxy schema fetch)
+ *   worker ──▶ main:   SchemaForSqlRequest        (proxy SQL block schema)
+ *   worker ──▶ main:   ReadUrlRequest             (proxy non-file URL reads)
+ *   main  ──▶ worker:  *Response                  (correlated by requestId)
+ *
+ *   main  ──▶ worker:  ShutdownRequest            (graceful drain)
+ *   worker ──▶ main:   ReadyMessage               (post-init handshake)
+ *
+ * The protocol uses plain structured-clonable POJOs so the
+ * `postMessage` transfer goes through V8's structured clone — much
+ * cheaper than `JSON.stringify` for the multi-MB modelDef payloads.
+ */
+
+import type {
+   Annotation,
+   SQLSourceDef,
+   TableSourceDef,
+} from "@malloydata/malloy";
+
+// ──────────────────────────────────────────────────────────────────────
+// Direction: main ──▶ worker (load-package job)
+// ──────────────────────────────────────────────────────────────────────
+
+/**
+ * Connection metadata the worker needs to construct a stub
+ * `InfoConnection`. Resolved lazily — the worker asks the main thread
+ * on the first `lookupConnection(name)` call (see
+ * {@link ConnectionMetadataRequest}). We don't ship the full list
+ * upfront because Malloy only references connections by name as it
+ * encounters `<connection>.table('...')` / `<connection>.sql('...')`
+ * inside the model.
+ */
+export interface ConnectionMetadata {
+   name: string;
+   dialectName: string;
+   digest: string;
+}
+
+export interface LoadPackageRequest {
+   type: "load-package";
+   requestId: string;
+   /** Absolute path to the package directory on disk. */
+   packagePath: string;
+   /** Logical package name (used in metric labels + log fields). */
+   packageName: string;
+   /**
+    * Default connection name (passed verbatim to the worker; today
+    * always `"duckdb"` for embedded packages, but kept configurable
+    * to mirror Malloy's own surface).
+    */
+   defaultConnectionName: string | null;
+   /** Optional row-build manifest passed through to Malloy Runtime. */
+   buildManifest?: unknown;
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Direction: worker ──▶ main (load-package result)
+// ──────────────────────────────────────────────────────────────────────
+
+/**
+ * Wire shape for one compiled model in the package. Mirrors the
+ * data a main-thread `Model` constructor needs without holding a
+ * `ModelMaterializer` reference (that binds to live native
+ * connection handles and can't cross the worker boundary).
+ *
+ * `compilationError` is set when this single model failed to
+ * compile but the rest of the package is fine; the main thread
+ * decides whether to abort `Package.create`.
+ */
+export interface SerializedModel {
+   /** Path relative to the package root, forward-slash normalized. */
+   modelPath: string;
+   modelType: "model" | "notebook";
+   /** Set when the model compiled successfully. Wire-typed as
+    *  `unknown` so the protocol module doesn't drag in the full
+    *  Malloy type surface; cast to `ModelDef` on receipt. */
+   modelDef?: unknown;
+   /**
+    * Precomputed `modelDefToModelInfo(modelDef)`. Shipped from the
+    * worker so the main-thread `Model` constructor doesn't pay the
+    * derivation cost on every package load and every subsequent
+    * `getModel()` / `getNotebook()` API hit can stringify a cached
+    * object instead of recomputing.
+    */
+   modelInfo?: unknown;
+   sourceInfos?: unknown[];
+   sources?: unknown[];
+   queries?: unknown[];
+   filterMap?: Array<[string, unknown[]]>;
+   givens?: unknown[];
+   /** Notebook (.malloynb) only — per-cell pre-extracted info. */
+   notebookCells?: SerializedNotebookCell[];
+   /** Accumulated dataStyles from sibling `.styles.json` files. */
+   dataStyles?: unknown;
+   /** Wall-clock ms spent compiling this single model in the worker. */
+   compileDurationMs?: number;
+   /** Set when the model failed to compile. */
+   compilationError?: SerializedError;
+}
+
+export interface SerializedNotebookCell {
+   type: "code" | "markdown";
+   /** Raw cell text. */
+   text: string;
+   /**
+    * Per-cell ModelDef captured at the cell's point in the
+    * `extendModel` chain. The main thread hydrates a per-cell
+    * `ModelMaterializer` from this via
+    * `Runtime._loadModelFromModelDef`, so cell-level filter
+    * refinement can compile new queries against the correct scope
+    * without ever recompiling the .malloynb itself.
+    */
+   cellModelDef?: unknown;
+   /**
+    * The final-query QueryDef for this cell, captured during the
+    * worker's compile. Main thread hydrates a `QueryMaterializer`
+    * via `ModelMaterializer._loadQueryFromQueryDef` — no recompile.
+    */
+   cellQueryDef?: unknown;
+   newSources?: unknown[];
+   queryInfo?: unknown;
+}
+
+export interface LoadPackageResult {
+   type: "load-package-result";
+   requestId: string;
+   packageMetadata: { name?: string; description?: string };
+   models: SerializedModel[];
+   /** Wall-clock ms inside the worker for the full package load. */
+   loadDurationMs: number;
+}
+
+export interface LoadPackageError {
+   type: "load-package-error";
+   requestId: string;
+   error: SerializedError;
+}
+
+/**
+ * Error wire-shape. We cannot transfer `Error` instances directly
+ * across `postMessage` cleanly (Bun/Node behaviour diverges on stack
+ * propagation), so we ship a structured payload and reconstitute on
+ * the main thread.
+ */
+export interface SerializedError {
+   name: string;
+   message: string;
+   stack?: string;
+   /** Set when the error originated as a Malloy `MalloyError`. */
+   malloyProblems?: unknown[];
+   /** Set when the error originated as `ModelCompilationError`. */
+   isCompilationError?: boolean;
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Direction: worker ──▶ main (proxy connection metadata)
+// ──────────────────────────────────────────────────────────────────────
+
+export interface ConnectionMetadataRequest {
+   type: "connection-metadata";
+   requestId: string;
+   jobId: string;
+   connectionName: string;
+}
+
+export interface ConnectionMetadataResponse {
+   type: "connection-metadata-response";
+   requestId: string;
+   ok: true;
+   metadata: ConnectionMetadata;
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Direction: worker ──▶ main (proxy schema fetches for non-duckdb)
+// ──────────────────────────────────────────────────────────────────────
+
+export interface SchemaForTablesRequest {
+   type: "schema-for-tables";
+   requestId: string;
+   /** Job this RPC belongs to (so main routes to the right config). */
+   jobId: string;
+   connectionName: string;
+   tables: Record<string, string>;
+   options: {
+      refreshTimestamp?: number;
+      modelAnnotation?: Annotation;
+   };
+}
+
+export interface SchemaForTablesResponse {
+   type: "schema-for-tables-response";
+   requestId: string;
+   ok: true;
+   schemas: Record<string, TableSourceDef>;
+   errors: Record<string, string>;
+}
+
+export interface SchemaForSqlRequest {
+   type: "schema-for-sql";
+   requestId: string;
+   jobId: string;
+   connectionName: string;
+   sentence: unknown;
+   options: {
+      refreshTimestamp?: number;
+      modelAnnotation?: Annotation;
+   };
+}
+
+export interface SchemaForSqlResponse {
+   type: "schema-for-sql-response";
+   requestId: string;
+   ok: true;
+   structDef?: SQLSourceDef;
+   error?: string;
+}
+
+export interface RpcErrorResponse {
+   type: "rpc-error";
+   requestId: string;
+   ok: false;
+   error: SerializedError;
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Direction: worker ──▶ main (file read for non-file URLs)
+// ──────────────────────────────────────────────────────────────────────
+
+/**
+ * Workers read most files directly via `fs` (they share the host's
+ * filesystem namespace). This RPC exists for the rare case where the
+ * package URL reader has host-specific behaviour (e.g. virtual files,
+ * remote URLs) — we delegate back to the main thread's URL reader so
+ * compile semantics stay identical to the in-process path.
+ */
+export interface ReadUrlRequest {
+   type: "read-url";
+   requestId: string;
+   jobId: string;
+   url: string;
+}
+
+export interface ReadUrlResponse {
+   type: "read-url-response";
+   requestId: string;
+   ok: true;
+   contents: string;
+   invalidationKey?: string | number | null;
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Lifecycle
+// ──────────────────────────────────────────────────────────────────────
+
+export interface ShutdownRequest {
+   type: "shutdown";
+}
+
+export interface ReadyMessage {
+   type: "ready";
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Union types for routing
+// ──────────────────────────────────────────────────────────────────────
+
+export type MainToWorkerMessage =
+   | LoadPackageRequest
+   | ConnectionMetadataResponse
+   | SchemaForTablesResponse
+   | SchemaForSqlResponse
+   | ReadUrlResponse
+   | RpcErrorResponse
+   | ShutdownRequest;
+
+export type WorkerToMainMessage =
+   | LoadPackageResult
+   | LoadPackageError
+   | ConnectionMetadataRequest
+   | SchemaForTablesRequest
+   | SchemaForSqlRequest
+   | ReadUrlRequest
+   | ReadyMessage;

package/src/query_param_utils.ts

@@ -0,0 +1,18 @@
+/**
+ * Express query-param normalization helpers.
+ *
+ * Kept in a standalone file (no transitive imports) so unit specs can
+ * exercise them without dragging in `server.ts` — which transitively
+ * constructs `EnvironmentStore` and kicks off an async storage init
+ * (clone of `malloy-samples`, package downloads, ...). When that init
+ * runs in a `bun test` process it races the test runner's exit and
+ * leaves a partially-populated `publisher_data/` on disk, which the
+ * next process (integration tests) then trips over.
+ */
+
+/** Normalize an Express query param into a string[] or undefined. */
+export function normalizeQueryArray(value: unknown): string[] | undefined {
+   if (value === undefined || value === null) return undefined;
+   if (Array.isArray(value)) return value.map(String);
+   return [String(value)];
+}

package/src/server-old.ts

@@ -41,7 +41,7 @@ import {
    NotImplementedError,
 } from "./errors";
 import { logger } from "./logger";
-import { normalizeQueryArray } from "./server";
+import { normalizeQueryArray } from "./query_param_utils";
 import { EnvironmentStore } from "./service/environment_store";
 
 const LEGACY_API_PREFIX = "/api/v0";

package/src/server.ts

@@ -1,4 +1,5 @@
 // Pre-load the instrumentation module; the instrumentation module must be loaded before the other imports.
+import type { GivenValue } from "@malloydata/malloy";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import bodyParser from "body-parser";
 import cors from "cors";
@@ -41,14 +42,10 @@ import { registerLegacyRoutes } from "./server-old";
 import { EnvironmentStore } from "./service/environment_store";
 import { ManifestService } from "./service/manifest_service";
 import { MaterializationService } from "./service/materialization_service";
+import { normalizeQueryArray } from "./query_param_utils";
 import { PackageMemoryGovernor } from "./service/package_memory_governor";
 
-/** Normalize an Express query param into a string[] or undefined. */
-export function normalizeQueryArray(value: unknown): string[] | undefined {
-   if (value === undefined || value === null) return undefined;
-   if (Array.isArray(value)) return value.map(String);
-   return [String(value)];
-}
+export { normalizeQueryArray } from "./query_param_utils";
 
 // Parse command line arguments
 function parseArgs() {
@@ -122,10 +119,12 @@ function parseArgs() {
    // Zero-config invocation (`npx @malloy-publisher/server`) opts in to
    // the bundled DuckDB-only sample config so the Quick Start works
    // without any flags. Any explicit --server_root or --config disables
-   // this — the user told us where to look. Skip in NODE_ENV=test so
-   // specs that import this module for utility helpers (e.g.
-   // db_utils.spec.ts -> normalizeQueryArray) don't get the bundled
-   // default leaked into their EnvironmentStore construction.
+   // this — the user told us where to look. Skip in NODE_ENV=test as a
+   // belt-and-suspenders so any spec that ends up evaluating this
+   // module doesn't accidentally pin the EnvironmentStore to the
+   // bundled malloy-samples config; query-param helpers have been
+   // moved to `./query_param_utils` precisely so unit specs no longer
+   // need to import this module at all.
    if (!sawServerRoot && !sawConfig && process.env.NODE_ENV !== "test") {
       process.env.PUBLISHER_USE_BUNDLED_DEFAULT = "true";
    }
@@ -1110,6 +1109,18 @@ app.get(
          const bypassFilters =
             req.query.bypass_filters === "true" ? true : undefined;
 
+         let givens: Record<string, GivenValue> | undefined;
+         if (typeof req.query.givens === "string") {
+            try {
+               givens = JSON.parse(req.query.givens);
+            } catch {
+               res.status(400).json({
+                  error: "Invalid givens: must be valid JSON",
+               });
+               return;
+            }
+         }
+
          res.status(200).json(
             await modelController.executeNotebookCell(
                req.params.environmentName,
@@ -1118,6 +1129,7 @@ app.get(
                cellIndex,
                filterParams,
                bypassFilters,
+               givens,
             ),
          );
       } catch (error) {
@@ -1178,6 +1190,7 @@ app.post(
                   | Record<string, string | string[]>
                   | undefined,
                req.body.bypassFilters === true ? true : undefined,
+               req.body.givens as Record<string, GivenValue> | undefined,
             ),
          );
       } catch (error) {
@@ -1221,6 +1234,7 @@ app.post(
             req.params.modelName,
             req.body.source,
             req.body.includeSql === true,
+            req.body.givens as Record<string, GivenValue> | undefined,
          );
          res.status(200).json(result);
       } catch (error) {
@@ -1431,6 +1445,18 @@ app.use(
    },
 );
 
+// Eagerly construct the package-load worker pool so we fail fast at
+// boot if PACKAGE_LOAD_WORKERS is misconfigured (e.g. set to 0, the
+// removed in-process fallback). Surfacing the bad config here is much
+// friendlier than surfacing it on the first package load, which could
+// be hours after start.
+{
+   const { getPackageLoadPool } = await import(
+      "./package_load/package_load_pool"
+   );
+   getPackageLoadPool();
+}
+
 const mainServer = http.createServer({ maxHeaderSize: 262144 }, app);
 
 mainServer.timeout = 600000;

package/src/service/db_utils.spec.ts

@@ -12,7 +12,7 @@ mock.module("@google-cloud/bigquery", () => ({
 }));
 
 import { Connection } from "@malloydata/malloy";
-import { normalizeQueryArray } from "../server";
+import { normalizeQueryArray } from "../query_param_utils";
 import {
    extractErrorDataFromError,
    getSchemasForConnection,

package/src/service/environment.ts

@@ -1,4 +1,4 @@
-import type { LogMessage } from "@malloydata/malloy";
+import type { GivenValue, LogMessage } from "@malloydata/malloy";
 import { MalloyError, Runtime } from "@malloydata/malloy";
 import { Mutex } from "async-mutex";
 import crypto from "crypto";
@@ -238,6 +238,7 @@ export class Environment {
       modelName: string,
       source: string,
       includeSql: boolean = false,
+      givens?: Record<string, GivenValue>,
    ): Promise<{ problems: LogMessage[]; sql?: string }> {
       assertSafePackageName(packageName);
       assertSafeRelativeModelPath(modelName);
@@ -308,7 +309,7 @@ export class Environment {
             if (includeSql) {
                try {
                   const queryMaterializer = modelMaterializer.loadFinalQuery();
-                  sql = await queryMaterializer.getSQL();
+                  sql = await queryMaterializer.getSQL({ givens });
                } catch {
                   // Source may not contain a runnable query (e.g. only source definitions),
                   // in which case we simply omit the sql field.

package/src/service/environment_store.ts

@@ -1,8 +1,8 @@
 import { GetObjectCommand, S3 } from "@aws-sdk/client-s3";
 import { Storage } from "@google-cloud/storage";
-import AdmZip from "adm-zip";
 import { Mutex } from "async-mutex";
 import crypto from "crypto";
+import extract from "extract-zip";
 import * as fs from "fs";
 import * as path from "path";
 import simpleGit from "simple-git";
@@ -884,6 +884,7 @@ export class EnvironmentStore {
    }
 
    public async unzipEnvironment(absoluteEnvironmentPath: string) {
+      const startedAt = Date.now();
       logger.info(
          `Detected zip file at "${absoluteEnvironmentPath}". Unzipping...`,
       );
@@ -897,8 +898,28 @@ export class EnvironmentStore {
       });
       await fs.promises.mkdir(unzippedEnvironmentPath, { recursive: true });
 
-      const zip = new AdmZip(absoluteEnvironmentPath);
-      zip.extractAllTo(unzippedEnvironmentPath, true);
+      // Stream-extract via yauzl (wrapped by extract-zip). Each entry's
+      // inflate and write are dispatched to the libuv thread pool, so the
+      // main event loop stays responsive even for very large archives.
+      // The previous adm-zip path used fs.readFileSync + zlib.inflateRawSync
+      // on the main thread, which parked the loop long enough on multi-
+      // hundred-MB packages to fail Kubernetes liveness probes mid-extract.
+      let entryCount = 0;
+      let totalUncompressedBytes = 0;
+      await extract(absoluteEnvironmentPath, {
+         dir: path.resolve(unzippedEnvironmentPath),
+         onEntry: (entry) => {
+            entryCount += 1;
+            totalUncompressedBytes += entry.uncompressedSize ?? 0;
+         },
+      });
+
+      const mib = (totalUncompressedBytes / (1024 * 1024)).toFixed(1);
+      logger.info(
+         `Unzipped "${absoluteEnvironmentPath}" -> "${unzippedEnvironmentPath}" ` +
+            `(${entryCount} entries, ${mib} MiB uncompressed) in ` +
+            `${formatDuration(Date.now() - startedAt)}`,
+      );
 
       return unzippedEnvironmentPath;
    }

package/src/service/filter_integration.spec.ts

@@ -133,6 +133,55 @@ import "child_orders.malloy"
 run: child_orders -> summary
 `;
 
+// Model with a given: declaration — view filters rows by the given value
+const MODEL_WITH_GIVENS = `##! experimental.givens
+
+given: target_region :: string is 'US'
+
+source: orders is duckdb.table('orders') extend {
+   primary_key: order_id
+
+   measure:
+      order_count is count()
+      total_amount is sum(amount)
+
+   view: by_given_region is {
+      where: region = $target_region
+      aggregate: order_count, total_amount
+   }
+}
+`;
+
+// Model with both a #(filter) annotation and a given: declaration to verify composition
+const MODEL_WITH_GIVENS_AND_FILTER = `##! experimental.givens
+
+given: target_region :: string is 'US'
+
+#(filter) dimension=status type=equal
+source: orders is duckdb.table('orders') extend {
+   primary_key: order_id
+
+   measure:
+      order_count is count()
+      total_amount is sum(amount)
+
+   view: by_given_region is {
+      where: region = $target_region
+      aggregate: order_count, total_amount
+   }
+}
+`;
+
+const NOTEBOOK_GIVENS = `>>>markdown
+# Givens Test
+
+>>>malloy
+import "orders_givens.malloy"
+
+>>>malloy
+run: orders -> by_given_region
+`;
+
 beforeAll(async () => {
    await fs.mkdir(TEST_DB_DIR, { recursive: true });
    await fs.mkdir(TEST_PKG_DIR, { recursive: true });
@@ -657,6 +706,67 @@ describe("filter integration", () => {
          expect(markdownCell.type).toBe("markdown");
          expect(markdownCell.text).toContain("Test Notebook");
       });
+
+      it("applies givens to notebook cell execution", async () => {
+         await writeFile("orders_givens.malloy", MODEL_WITH_GIVENS);
+         await writeFile("givens_notebook.malloynb", NOTEBOOK_GIVENS);
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "givens_notebook.malloynb",
+            getConnections(),
+         );
+
+         // Cell 2: run: orders -> by_given_region with target_region overridden to 'EU'
+         // EU rows: (3,'EU','active',150) and (4,'EU','cancelled',75) → order_count=2, total_amount=225
+         const codeCell = await model.executeNotebookCell(
+            2,
+            undefined,
+            undefined,
+            { target_region: "EU" },
+         );
+         expect(codeCell.result).toBeDefined();
+
+         const notebookRows = parseNotebookResult(codeCell.result!);
+         expect(notebookRows.length).toBe(1);
+         expect(Number(notebookRows[0].order_count)).toBe(2);
+         expect(Number(notebookRows[0].total_amount)).toBe(225);
+      });
+
+      it("composes givens and filterParams in notebook cell execution", async () => {
+         await writeFile(
+            "orders_givens_filter.malloy",
+            MODEL_WITH_GIVENS_AND_FILTER,
+         );
+         await writeFile(
+            "givens_filter_notebook.malloynb",
+            NOTEBOOK_GIVENS.replace(
+               "orders_givens.malloy",
+               "orders_givens_filter.malloy",
+            ),
+         );
+         const model = await Model.create(
+            "test-pkg",
+            TEST_PKG_DIR,
+            "givens_filter_notebook.malloynb",
+            getConnections(),
+         );
+
+         // given restricts to APAC; filterParam restricts to active
+         // APAC + active: only (5,'APAC','active',300) → order_count=1, total_amount=300
+         const codeCell = await model.executeNotebookCell(
+            2,
+            { status: "active" },
+            undefined,
+            { target_region: "APAC" },
+         );
+         expect(codeCell.result).toBeDefined();
+
+         const notebookRows = parseNotebookResult(codeCell.result!);
+         expect(notebookRows.length).toBe(1);
+         expect(Number(notebookRows[0].order_count)).toBe(1);
+         expect(Number(notebookRows[0].total_amount)).toBe(300);
+      });
    });
 
    // -----------------------------------------------------------------------