@sun-asterisk/sungen 3.2.10 → 3.2.12-beta.1

package/dist/orchestrator/templates/ai-src/skills/sungen-data-factory/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: sungen-data-factory
+description: 'Use when create-data-test (or create-test) needs standardized TEST DATA — valid/boundary/invalid values for input fields with CHK-* traceability. Drives the Data Factory catalog + the 4-source method. Invoke after reading spec.md, when authoring the field-map or filling test-data.'
+user-invocable: false
+---
+
+## What this skill does
+
+Turn a screen/flow's fields into **standardized test data** — not guessed values. You author a
+**field-map**; the deterministic `sungen data gen` expands it from the Data Factory **catalog**
+(field-type + security + technique library) into valid / boundary / invalid values, each carrying a
+`CHK-*` id that traces to the spec. Your judgment goes into *reading the spec correctly* and
+*answering blind spots* — never into inventing values the catalog or the QA should own.
+
+Data Factory is **bundled with core** (runtime-free) — no `capability add` needed; the `sungen data …`
+CLI is available out of the box.
+
+## The 4-source method (phuong-phap-tao-test-data.md)
+
+Never invent values from memory. Cross-reference four sources — each covers the previous one's gap:
+
+1. **Spec validate rules** — required, format, min/max, business rules, and the **error/message code**
+   per rule. Defines the legal/illegal boundary. (Says the *law*, not every way to *break* it.)
+2. **Field-type catalog** — the accumulated "how this type breaks" knowledge (email/password/phone/
+   number/…). This is the Data Factory `common/` — it fills the "spec doesn't list every break" gap.
+3. **Design technique** — Boundary Value Analysis / Equivalence Partitioning / Decision Table / State
+   Transition — reduces the rule + candidates to a *minimal-but-sufficient* representative set.
+4. **DB mapping** — unique constraints, cross-entity dependency, real backend limits → precondition
+   data, not just a single input value.
+
+Then classify every value into **Valid / Boundary / Invalid** (each invalid tagged with its error
+code) and give it a `CHK-*` id for traceability.
+
+## The field-map — `qa/data-factory/<name>.fields.yaml`
+
+Your main artifact. One entry per input field; the generator expands it:
+
+```yaml
+screen: login                 # or  flow: <name>
+fields:
+  - name: email
+    type: email               # a catalog field-type (see list below)
+    required: true
+    constraints: { maxLocal: 64, maxTotal: 254 }   # the project's REAL limits from spec
+    errorMap: { M13: E1042, M02: E1001 }            # catalog placeholder code → project's real code
+  - name: password
+    type: password
+    constraints: { minLength: 8, maxLength: 32 }
+```
+
+**Catalog field-types** (P1): `email` · `password` · `phone` · `string` · `number-integer` ·
+`number-float` · `currency` · `postcode` · `katakana` (JP). Security payload banks auto-append to a
+field's invalid group via the type's `uses_security` (`sqli`, `xss`, `idor`, `broken-auth`, `upload`,
+`input-validation`).
+
+Rules:
+- Pick the closest `type`; put the project's real numbers in `constraints` (they override the
+  catalog defaults).
+- Map every `errorRef` placeholder (`M13`, `M39`, …) to the spec's real code via `errorMap`. Leave
+  one unmapped **only** if the spec has none — the lint flags it as an open point to confirm.
+- **Complex forms:** a **group** field takes nested **`fields:`** (recursive; no `type` on the group → renders a nested object like `address.city`). A field whose rule depends on another takes **`dependsOn: { field, value }`** — recorded as a `_depends_on` note (the generator doesn't resolve the runtime condition; weave it into the scenario/`@cases`).
+- Set **`unique: true`** on a field that must be fresh every run (register email/username, anything
+  that would clash with a record a previous run left behind). Its valid value then carries a runtime
+  `{{$timestamp}}` (email → `user+{{$timestamp}}@…`) so each run is unique — no cross-run cache
+  (which would make tests order-dependent/flaky). Prefer this over caching prior-run values. For
+  reusing a value produced earlier **within the same run** (register → then log in with it), bind it
+  via the scenario (`@dataFactory` recipe / `testData.bind`), not a cross-run cache.
+
+## No input fields → nothing to generate
+
+Data Factory standardizes **field-level input data**. If a unit has no user-input fields or
+parameters — a pure navigation, listing, or capture-compare flow — there is nothing to generate.
+Report *"no input fields → nothing to generate"* and skip it; do **not** write an empty field-map.
+Those scenarios are covered by the data create-test already produced, not by field-level test data.
+(This is a correct outcome, not a gap — don't force a field-map to make the unit "processed".)
+
+## Blind spots — ask, never fabricate
+
+If a field's type is **not** in the catalog — a business enum, a cross-entity constraint, a
+project-specific data model — do **not** guess. Ask the QA (via `AskUserQuestion`) for: (1) the valid
+set, (2) invalid / non-existent values, (3) the error code when wrong, (4) dependencies on other
+fields. Record it in `qa/data-factory/project/<entity>.yaml` so it becomes reusable project catalog.
+This is the core discipline: *common is never enough; when blind, think and ask — don't invent.*
+
+## Customizing the catalog — `.overwrite` (survives `sungen update`)
+
+The shipped `common/` is a floor. Project rules go in `qa/data-factory/common.overwrite.yaml`,
+deep-merged over the common (**later-wins**, keyed by `type` + data-point `id`): same `id` replaces,
+new `id` appends, `constraints` merge key-by-key. `sungen update` refreshes `common/` but never
+touches your overlay. If an update makes an overlay entry stale (references a bank/constraint that no
+longer exists), the loader **warns you to prune it** — it never edits your file. Prefer a targeted
+`errorMap`/`constraints` in the field-map for per-screen tweaks; use `.overwrite` only for rules that
+apply project-wide.
+
+## Bulk-import fixtures (CSV)
+
+For CSV/Excel import or bulk-upload testing, `sungen data fixture --screen <name> [--rows N] [--invalid]`
+turns the field-map into a fixture FILE under `qa/fixtures/`: `<name>.csv` (N valid rows; nested groups
+→ dotted headers; `unique` fields row-indexed) that should import cleanly, and — with `--invalid` —
+`<name>.invalid.csv` (one seeded-bad row per field + a `_violation` column) for row-level rejection
+tests. Reference it from an `@api` upload (`files:`) or a UI file input.
+
+## Verify before done — the phuong-phap §6 checklist
+
+Run `sungen data lint` and clear it: every required field has **≥1 valid**, **boundary present**
+(exact min/max, not only over-boundary) for bounded types, **≥1 invalid per rule** (not one generic
+"wrong" value for many rules), no `UNRESOLVED` values, error codes mapped or explicitly left open.
+Then `sungen data gen` writes the standardized `test-data/<name>.yaml`. Do not hand-edit the
+generated values — change the field-map or `.overwrite` and re-run (determinism: same input → same
+data).
+
+## Weaving into scenarios
+
+When a `.feature` exists, express invalid/boundary sets as data-driven `Scenario Outline` + `Examples`
+(`@cases`) referencing the values — see `sungen-gherkin-syntax`. This keeps one logic + many values
+instead of copy-pasted scenarios, and each row carries its `CHK-*` id for traceability.

package/dist/orchestrator/templates/ai-src/skills/sungen-gherkin-syntax/SKILL.md

@@ -143,14 +143,24 @@ Scenario: ...
 
 Path access on a bound result: `{{q.count}}`/`{{q.length}}`, `{{q.first.col}}`, `{{q.last.col}}`, `{{q[2].col}}`, `{{q.col}}` (= first row's col). `expect A is B` also supports `is at least` / `is at most` / `is not`. Tier-2 declarative (trivial inline, no catalog): `User see [<table>] row where [<col>] is {{v}} [has [<col2>] = "x"]`, `… no row where …`, `… count is {{n}}`. Full grammar + catalog/datasource/secret rules → **Advanced → Database** doc. Only emit DB steps when the project has a `database/` catalog / `datasources.yaml`.
 
+### NoSQL engines (Cosmos, MongoDB, DynamoDB) — natively supported
+
+Beyond the three SQL engines, the Data Driver has native NoSQL engines. Declarative steps (`User see [table] row where …`, `… no row …`, `… count is …`) work across ALL of them; only the raw `@query` catalog shape differs per engine:
+
+- **`engine: cosmos`** (Azure Cosmos DB, NoSQL API) — SQL dialect. Author `sql:` catalog entries against the mandatory `c` alias (`SELECT * FROM c WHERE c.<field> = :p`); named params bind automatically. Config: `endpoint`+`key` (or a connection-string `url`), `database`, `container` (default when no `[table]`). Read-only by construction (the query API can't mutate).
+- **`engine: mongodb`** — no SQL. Author a `find:` (`{collection, filter, projection?, sort?, limit?}`) or `pipeline:` (`{collection, stages: […]}`) catalog entry; `:param` placeholders bind at runtime. `$out`/`$merge`/`$where`/`$function`/`$accumulator`/`mapReduce` are refused. Config: a `mongodb://` `url`. Read-only = a server-side read role.
+- **`engine: dynamodb`** — raw `@query` is PartiQL SELECT (`sql: SELECT … FROM "table" WHERE pk = :p`). Declarative steps route GetItem/Query only for partition-/sort-key filters via a `keySchema:` registry; a **non-key filter is refused** (use a raw PartiQL SELECT — never a full-table Scan). Config: `region` + `keySchema` (credentials from the AWS env chain). Read-only = IAM `PartiQLSelect`-only.
+
+Full config + catalog examples → **Advanced → Database** doc.
+
 ### Unsupported DB engine — fallback (ask, don't improvise)
 
-Direct SQL verification (`@query`, the Data Driver) only supports these engines: **`{postgres, sqlite, mysql}`**. When a datasource's `engine` (or the DB the user describes) is **outside this set** — e.g. Cosmos NoSQL, MongoDB, Cassandra, DynamoDB:
+Direct SQL verification (`@query`, the Data Driver) covers these SQL engines: **`{postgres, sqlite, mysql}`** — plus the three native NoSQL engines above (Cosmos, MongoDB, DynamoDB). When a datasource's `engine` (or the DB the user describes) is **outside all of those** — e.g. Cassandra, Oracle, Neo4j, a proprietary store:
 
 1. **Do not** attempt a direct connect. **Do not** improvise a verification method.
 2. Present a fixed `AskUserQuestion` with exactly these 3 branches (always these, no others invented):
    - **@api** — verify state via the project's internal API (route to the API driver).
-   - **@manual** — emit a `@manual` step + manual-check guidance (e.g. Cosmos Data Explorer, `az cosmosdb`, the vendor CLI).
+   - **@manual** — emit a `@manual` step + manual-check guidance (e.g. the vendor console / CLI — `cqlsh` for Cassandra, `cypher-shell` for Neo4j).
    - **Proxy / read-replica SQL** — if the user can supply a SQL-compatible endpoint (including Azure Cosmos DB **for PostgreSQL** / Citus), treat it as `engine: postgres` (or `mysql`) and use the normal Data Driver path above.
 3. **Recommend, don't decide.** Check the project for signals and put the best-fit branch **first**, tagged **"(Recommended)"** with a one-line reason:
    - a project API driver / `qa/api/` catalog / `PEERCONNE_URL`-style internal API exists → **@api** first;
@@ -163,11 +173,11 @@ Direct SQL verification (`@query`, the Data Driver) only supports these engines:
 Example:
 ```
 AskUserQuestion:
-  question: "This datasource's engine (cosmos-nosql) isn't in {postgres, sqlite, mysql} — direct SQL connect isn't supported. How should DB state be verified?"
+  question: "This datasource's engine (cassandra) isn't a supported Data Driver engine ({postgres, sqlite, mysql} + Cosmos/MongoDB/DynamoDB) — direct connect isn't supported. How should DB state be verified?"
   options:
     - "@api — verify via the project's internal API (Recommended: qa/api/ catalog found)"
-    - "@manual — emit a @manual step + Cosmos Data Explorer / az cosmosdb check"
-    - "Proxy / read-replica SQL — supply a SQL-compatible endpoint (e.g. Cosmos DB for PostgreSQL) → engine: postgres"
+    - "@manual — emit a @manual step + cqlsh check"
+    - "Proxy / read-replica SQL — supply a SQL-compatible endpoint → engine: postgres"
     - "Other — describe your own verification approach"
 ```
 

package/dist/orchestrator/templates/ai-src/skills/sungen-tc-generation/SKILL.md

@@ -6,6 +6,7 @@ user-invocable: false
 
 ## ⚠️ Gotchas — read before generating
 
+- **Field-level test-data follows the Data Factory standard — don't hand-invent values.** When the unit has input fields, the field values (valid / boundary / invalid + error codes) come from the **`sungen-data-factory`** catalog via a field-map + `sungen data gen` (create-test step 5.3), not free-form guessing. Weave the standardized boundary/invalid sets into `@cases` with `CHK-*` trace. This skill still owns scenario structure, viewpoints, and non-field oracles.
 - **Write incrementally — never emit the whole suite in one response.** Build the `.feature` in batches via successive `Write`/`Edit` (≈10–15 scenarios per call). For **Full coverage**, write tier-by-tier: `Write` Tier 1 → `Edit` append Tier 2 → `Edit` append Tier 3.
   → One huge `Write` can exceed the model's output-token cap → `API Error: Claude's response exceeded the N output token maximum`. Single-pass full coverage only fits when `CLAUDE_CODE_MAX_OUTPUT_TOKENS ≥ 64000`; otherwise batch. Batching also lets the audit/reviewer run per batch — higher quality.
 

package/dist/orchestrator/templates/specs-db.d.ts

@@ -1,36 +1,226 @@
 /**
- * `build()` always emits PG-style `$1..$n` placeholders; mysql2/better-sqlite3 both bind with `?`.
- * Only real placeholders are rewritten — a `$1` sitting inside a single-quoted string literal (e.g.
- * a catalog query `WHERE label = '$1 off'`) is left untouched. SQL escapes an inner quote by doubling
- * it (`''`), which the simple in-string toggle handles (an even number of quotes returns to the same state).
+ * `build()` always emits PG-style `$1..$n` placeholders; mysql2/better-sqlite3 both bind with
+ * positional `?` (left-to-right). Rewriting `$n`→`?` must therefore ALSO reorder the params to the
+ * textual placeholder order: an author-written catalog query `WHERE a = $2 AND b = $1` becomes
+ * `a = ? AND b = ?`, so the params must be bound `[params[1], params[0]]` — otherwise the values
+ * silently swap and the query returns wrong rows. A repeated `$k` duplicates its value at each `?`.
+ * Postgres binds `$n` natively, so it is returned untouched.
+ *
+ * Only real placeholders are rewritten — a `$1` inside a single-quoted string literal (e.g.
+ * `WHERE label = '$1 off'`) is left untouched. SQL escapes an inner quote by doubling it (`''`),
+ * which the simple in-string toggle handles (an even number of quotes returns to the same state).
+ *
+ * DynamoDB PartiQL binds the same positional `?` as mysql2/sqlite, so it shares this path — the
+ * reorder is essential there too (an author-written PartiQL `WHERE sk = $2 AND pk = $1`).
  */
-export declare function rewritePlaceholders(engine: string, sql: string): string;
+export declare function rewritePlaceholders(engine: string, sql: string, params: any[]): {
+    sql: string;
+    params: any[];
+};
+/**
+ * Engine contract — the assertion surface is engine-agnostic; each engine owns its own dialect so
+ * a NoSQL store (Cosmos / MongoDB / DynamoDB) can back the same declarative steps as SQL.
+ *   findRows(table, filter, limit) — rows matching an equality filter, capped at `limit`
+ *   countRows(table, filter)       — count of rows matching an equality filter
+ *   runQuery(label, sql, params)   — a raw catalog query (read-only). SQL dialects (incl. Cosmos SQL
+ *                                    and DynamoDB PartiQL) take a SQL string; MongoDB's non-SQL
+ *                                    find/pipeline shapes are dispatched separately via fetchQueryShape.
+ */
+interface Engine {
+    findRows(table: string, filter: Record<string, any>, limit: number): Promise<any[]>;
+    countRows(table: string, filter: Record<string, any>): Promise<number>;
+    runQuery(label: string, sql: string, params: any[]): Promise<any[]>;
+    runShape?(label: string, shape: ShapeQuery, params: Record<string, any>): Promise<any[]>;
+}
+/** A MongoDB catalog entry's runtime shape: exactly one of find/pipeline, with `:param` placeholders bound at runtime. */
+type ShapeQuery = {
+    find?: {
+        collection: string;
+        filter?: Record<string, any>;
+        projection?: Record<string, any>;
+        sort?: Record<string, any>;
+        limit?: number;
+    };
+    pipeline?: {
+        collection: string;
+        stages: any[];
+    };
+};
+/** Minimal shape of an @azure/cosmos container the engine uses — kept local so the SDK stays a lazy dep. */
+type CosmosContainer = {
+    items: {
+        query(spec: {
+            query: string;
+            parameters: Array<{
+                name: string;
+                value: any;
+            }>;
+        }, opts?: any): {
+            fetchAll(): Promise<{
+                resources: any[];
+            }>;
+        };
+    };
+};
+/**
+ * Azure Cosmos DB (NoSQL API) engine. The Cosmos query API is read-only by construction — `.query()`
+ * only ever reads; mutations require item-level APIs this engine never calls — so the SELECT guard is
+ * defense-in-depth. Cosmos binds NAMED params (`@p`), so it is immune to the positional-`?` reorder
+ * hazard. A step/catalog `[table]` selects the container; `SELECT * FROM c` uses the mandatory `c` alias.
+ */
+export declare class CosmosEngine implements Engine {
+    private getContainer;
+    private opts;
+    constructor(getContainer: (name?: string) => CosmosContainer, opts: {
+        timeoutMs: number;
+        maxRows: number;
+    });
+    private query;
+    /** Build `c.<col> = @p<i>` equality predicates over the mandatory `c` alias. Columns are identifier-checked. */
+    private whereFor;
+    findRows(table: string, filter: Record<string, any>, limit: number): Promise<any[]>;
+    countRows(table: string, filter: Record<string, any>): Promise<number>;
+    runQuery(label: string, sql: string, params: any[]): Promise<any[]>;
+}
+/**
+ * Rewrite compiled positional `$n` placeholders to Cosmos NAMED params (`@pN`) and collect the
+ * matching parameter list. A `$n` inside a single-quoted string literal is left untouched (same
+ * in-string toggle as the SQL rewrite); a repeated `$n` reuses its one `@pN` entry.
+ */
+export declare function cosmosBindParams(sql: string, params: any[]): {
+    query: string;
+    parameters: Array<{
+        name: string;
+        value: any;
+    }>;
+};
+/** Minimal shapes of the mongodb driver objects the engine uses — kept local so the SDK stays a lazy dep. */
+type MongoCursor = {
+    project(p: any): MongoCursor;
+    sort(s: any): MongoCursor;
+    limit(n: number): MongoCursor;
+    maxTimeMS(t: number): MongoCursor;
+    toArray(): Promise<any[]>;
+};
+type MongoCollection = {
+    find(filter: any): MongoCursor;
+    countDocuments(filter: any, opts?: any): Promise<number>;
+    aggregate(pipeline: any[], opts?: any): {
+        toArray(): Promise<any[]>;
+    };
+};
+/**
+ * MongoDB engine. There is no SQL — declarative steps map to native find()/countDocuments(), and the
+ * raw `@query` path takes a find/pipeline shape (via fetchQueryShape → runShape) rather than a SQL
+ * string. Type-strict matching (`{age:30}` ≠ `{age:"30"}`) is why DB params bind via raw() (native
+ * type), not the stringifying get(). Read-only is enforced first by the server-side read role, with
+ * the operator blocklist as in-driver defense-in-depth. Per-query `maxTimeMS` + row cap bound cost.
+ */
+export declare class MongoEngine implements Engine {
+    private getCollection;
+    private opts;
+    constructor(getCollection: (name: string) => MongoCollection, opts: {
+        timeoutMs: number;
+        maxRows: number;
+    });
+    findRows(table: string, filter: Record<string, any>, limit: number): Promise<any[]>;
+    countRows(table: string, filter: Record<string, any>): Promise<number>;
+    runQuery(label: string): Promise<any[]>;
+    runShape(label: string, shape: ShapeQuery, params: Record<string, any>): Promise<any[]>;
+}
+/** The three read-only DynamoDB operations the engine needs, over the auto-marshalling Document client. */
+type DynamoOps = {
+    executeStatement(input: {
+        Statement: string;
+        Parameters?: any[];
+        Limit?: number;
+        NextToken?: string;
+    }, signal?: AbortSignal): Promise<{
+        Items?: any[];
+        NextToken?: string;
+    }>;
+    getItem(input: {
+        TableName: string;
+        Key: Record<string, any>;
+    }, signal?: AbortSignal): Promise<{
+        Item?: any;
+    }>;
+    query(input: {
+        TableName: string;
+        KeyConditionExpression: string;
+        ExpressionAttributeNames: Record<string, string>;
+        ExpressionAttributeValues: Record<string, any>;
+        Select?: string;
+        Limit?: number;
+        ExclusiveStartKey?: Record<string, any>;
+    }, signal?: AbortSignal): Promise<{
+        Items?: any[];
+        Count?: number;
+        LastEvaluatedKey?: Record<string, any>;
+    }>;
+};
+type KeySchema = Record<string, {
+    partitionKey: string;
+    sortKey?: string | null;
+}>;
+/**
+ * DynamoDB engine. The clean primary path is raw `@query` PartiQL SELECT (positional `?`, reordered
+ * via the shared placeholder rewrite). Declarative assertRow/count is structurally constrained by
+ * DynamoDB's key model: it routes GetItem/Query only for pk / pk+sk filters (via the `keySchema`
+ * registry) and REFUSES a non-key filter rather than falling back to an unaffordable full-table Scan.
+ * Read-only is primarily IAM (`dynamodb:PartiQLSelect` only); the SELECT guard is defense-in-depth.
+ */
+export declare class DynamoEngine implements Engine {
+    private ops;
+    private keySchema;
+    private opts;
+    constructor(ops: DynamoOps, keySchema: KeySchema, opts: {
+        timeoutMs: number;
+        maxRows: number;
+    });
+    private withTimeout;
+    /** Decide how a flat equality filter maps to a key-based access pattern, or refuse it. */
+    private route;
+    findRows(table: string, filter: Record<string, any>, limit: number): Promise<any[]>;
+    countRows(table: string, filter: Record<string, any>): Promise<number>;
+    runQuery(label: string, sql: string, params: any[]): Promise<any[]>;
+}
 declare class DataSource {
     private configs;
     private engines;
     private tunnels;
     private mysqlPools;
+    private mongoClients;
     private cfg;
     private engine;
-    /** Close open MySQL pools + SSH tunnels (optional explicit teardown; tunnels are unref'd so the process exits regardless). */
+    /** Build the lazy driver-call closure for a SQL engine (pg/mysql/sqlite), incl. the optional SSH-tunnel fallback. */
+    private sqlExec;
+    /** Build the Cosmos engine — connect via endpoint+key or a connection-string url; resolve containers by name. */
+    private cosmosEngine;
+    /** Build the MongoDB engine — one reused client per datasource; the db comes from `database` or the URI default. */
+    private mongoEngine;
+    /** Build the DynamoDB engine — region + credentials from the AWS env chain; wraps the Document client's three read ops. */
+    private dynamoEngine;
+    /** Close open MySQL pools + Mongo clients + SSH tunnels (optional explicit teardown; tunnels are unref'd so the process exits regardless). */
     close(): void;
-    private build;
     /** A row matching `filter` must exist; if `expected` given, assert those columns on the first match. */
     assertRow(table: string, filter: Record<string, any>, expected?: Record<string, any>, datasource?: string): Promise<void>;
     /** No row matching `filter` may exist. */
     assertNoRow(table: string, filter: Record<string, any>, datasource?: string): Promise<void>;
     /** Exactly `count` rows must match `filter`. */
     assertCount(table: string, filter: Record<string, any>, count: number, datasource?: string): Promise<void>;
-    /** Rewrites $1/$2 placeholders to `?` for engines that don't support PG-style positional params. */
-    private sqlFor;
-    /** Read-only guard (second layer): a named query must be a single SELECT/WITH statement. */
-    private assertSelectOnly;
     /**
      * Run a catalog query (read-only) and return its rows. The result is bound to a `{{name}}`
      * variable via `testData.bind(...)`, so the scenario asserts on it with `expect …` steps and
      * path access (`{{name.count}}`, `{{name.first.col}}`, `{{name[2].col}}`).
      */
     fetchQuery(label: string, sql: string, params: any[], datasource?: string): Promise<any[]>;
+    /**
+     * Run a MongoDB find/pipeline catalog query (read-only) and return its documents. Same binding
+     * contract as fetchQuery, but the query is a structured shape (not SQL) with `:param` placeholders
+     * bound from `params` at runtime. Refused on an engine that has no non-SQL shape support.
+     */
+    fetchQueryShape(label: string, shape: ShapeQuery, params: Record<string, any>, datasource?: string): Promise<any[]>;
 }
 export declare const db: DataSource;
 export {};

package/dist/orchestrator/templates/specs-db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"specs-db.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/templates/specs-db.ts"],"names":[],"mappings":"AA8HA;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAiBvE;AAID,cAAM,UAAU;IACd,OAAO,CAAC,OAAO,CAAiD;IAChE,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,OAAO,CAAoC;IACnD,OAAO,CAAC,UAAU,CAA2C;IAE7D,OAAO,CAAC,GAAG;YAQG,MAAM;IAkEpB,8HAA8H;IAC9H,KAAK,IAAI,IAAI;IAOb,OAAO,CAAC,KAAK;IAOb,wGAAwG;IAClG,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAc/H,0CAA0C;IACpC,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOjG,gDAAgD;IAC1C,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUhH,oGAAoG;IACpG,OAAO,CAAC,MAAM;IAKd,4FAA4F;IAC5F,OAAO,CAAC,gBAAgB;IASxB;;;;OAIG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;CAKjG;AAMD,eAAO,MAAM,EAAE,YAAmB,CAAC"}
+{"version":3,"file":"specs-db.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/templates/specs-db.ts"],"names":[],"mappings":"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"}