@dbx-tools/appkit-generator 0.0.0-stage → 0.9.138

package/lib/src/dashboard.js

@@ -0,0 +1,257 @@
+/**
+ * Deterministic AI/BI dashboard assembly and OBO publication.
+ *
+ * @module
+ */
+import { ExecutionError } from "@databricks/appkit";
+import { databricks } from "@dbx-tools/appkit";
+import { hash } from "@dbx-tools/shared-core";
+import { GeneratedDashboardSchema, } from "@dbx-tools/shared-generator/workflow";
+import { z } from "zod";
+import { resolveGeneratorIdentity } from "./namespace.js";
+const SerializedDashboardSchema = z
+    .object({
+    datasets: z.array(z.record(z.string(), z.unknown())).min(1),
+    pages: z.array(z.record(z.string(), z.unknown())).min(1),
+    uiSettings: z.record(z.string(), z.unknown()),
+})
+    .strict();
+/** Compile one metric into a reusable Lakeview dataset measure. */
+function measure(metric) {
+    const expression = metric.aggregation === "count"
+        ? "COUNT(`*`)"
+        : `${metric.aggregation === "sum" ? "SUM" : "AVG"}(\`${metric.column}\`)`;
+    return {
+        displayName: metric.label,
+        description: metric.definition,
+        expression,
+    };
+}
+/** Counter widget bound to one dataset measure. */
+function counterWidget(metric, index) {
+    const fieldName = `measure(${metric.label})`;
+    return {
+        widget: {
+            name: `kpi_${metric.name}`,
+            queries: [
+                {
+                    name: "main_query",
+                    query: {
+                        datasetName: "generated_facts",
+                        fields: [{ name: fieldName, expression: `MEASURE(\`${metric.label}\`)` }],
+                        disaggregated: false,
+                    },
+                },
+            ],
+            spec: {
+                version: 2,
+                widgetType: "counter",
+                encodings: {
+                    value: {
+                        fieldName,
+                        displayName: metric.label,
+                        ...(metric.unit === "percent"
+                            ? {
+                                format: {
+                                    type: "number-percent",
+                                    decimalPlaces: { type: "max", places: 2 },
+                                },
+                            }
+                            : {}),
+                    },
+                },
+                frame: { showTitle: true, title: metric.label },
+            },
+        },
+        position: {
+            x: (index % 3) * 4,
+            y: 2 + Math.floor(index / 3) * 3,
+            width: 4,
+            height: 3,
+        },
+    };
+}
+/** Build one complete dashboard with automatic companion Genie enabled. */
+export function buildGeneratorDashboard(input) {
+    const fullTable = `${input.location.catalog}.${input.location.schema}.${input.plan.table}`;
+    const dateColumn = input.plan.columns.find(({ generator }) => generator === "date")?.name;
+    const categoryColumn = input.plan.columns.find(({ generator }) => generator === "category")?.name;
+    const metric = input.plan.metrics[0];
+    const metricField = `measure(${metric.label})`;
+    const kpiRows = Math.ceil(input.plan.metrics.length / 3);
+    const chartY = 2 + kpiRows * 3;
+    const layout = [
+        {
+            widget: {
+                name: "header",
+                multilineTextboxSpec: {
+                    lines: [`# ${input.company}: ${input.purpose}\n`, `\n`, input.plan.story],
+                },
+            },
+            position: { x: 0, y: 0, width: 12, height: 2 },
+        },
+        ...input.plan.metrics.map(counterWidget),
+    ];
+    if (dateColumn) {
+        layout.push({
+            widget: {
+                name: "metric_trend",
+                queries: [
+                    {
+                        name: "main_query",
+                        query: {
+                            datasetName: "generated_facts",
+                            fields: [
+                                {
+                                    name: `daily(${dateColumn})`,
+                                    expression: `DATE_TRUNC("DAY", \`${dateColumn}\`)`,
+                                },
+                                { name: metricField, expression: `MEASURE(\`${metric.label}\`)` },
+                            ],
+                            disaggregated: false,
+                        },
+                    },
+                ],
+                spec: {
+                    version: 3,
+                    widgetType: "line",
+                    encodings: {
+                        x: {
+                            fieldName: `daily(${dateColumn})`,
+                            scale: { type: "temporal" },
+                            displayName: "Date",
+                        },
+                        y: {
+                            fieldName: metricField,
+                            scale: { type: "quantitative" },
+                            displayName: metric.label,
+                        },
+                    },
+                    frame: { showTitle: true, title: `${metric.label} trend` },
+                },
+            },
+            position: { x: 0, y: chartY, width: 7, height: 6 },
+        });
+    }
+    if (categoryColumn) {
+        layout.push({
+            widget: {
+                name: "metric_by_category",
+                queries: [
+                    {
+                        name: "main_query",
+                        query: {
+                            datasetName: "generated_facts",
+                            fields: [
+                                { name: categoryColumn, expression: `\`${categoryColumn}\`` },
+                                { name: metricField, expression: `MEASURE(\`${metric.label}\`)` },
+                            ],
+                            disaggregated: false,
+                        },
+                    },
+                ],
+                spec: {
+                    version: 3,
+                    widgetType: "bar",
+                    encodings: {
+                        x: {
+                            fieldName: categoryColumn,
+                            scale: { type: "categorical" },
+                            displayName: categoryColumn,
+                        },
+                        y: {
+                            fieldName: metricField,
+                            scale: { type: "quantitative" },
+                            displayName: metric.label,
+                        },
+                    },
+                    frame: { showTitle: true, title: `${metric.label} by ${categoryColumn}` },
+                },
+            },
+            position: { x: 7, y: chartY, width: 5, height: 6 },
+        });
+    }
+    return SerializedDashboardSchema.parse({
+        datasets: [
+            {
+                name: "generated_facts",
+                displayName: input.plan.table,
+                asset_name: fullTable,
+                columns: input.plan.metrics.map(measure),
+            },
+        ],
+        pages: [
+            {
+                name: "overview",
+                displayName: "Overview",
+                pageType: "PAGE_TYPE_CANVAS",
+                layoutVersion: "GRID_V1",
+                layout,
+            },
+        ],
+        uiSettings: {
+            theme: {
+                canvasBackgroundColor: {
+                    light: input.brand.colors.background,
+                    dark: input.brand.colors.foreground,
+                },
+                widgetBackgroundColor: {
+                    light: input.brand.colors.surface,
+                    dark: input.brand.colors.primary,
+                },
+                fontColor: {
+                    light: input.brand.colors.foreground,
+                    dark: input.brand.colors.background,
+                },
+                selectionColor: {
+                    light: input.brand.colors.primary,
+                    dark: input.brand.colors.accent,
+                },
+                visualizationColors: [
+                    input.brand.colors.primary,
+                    input.brand.colors.accent,
+                    input.brand.colors.primaryHover,
+                    input.brand.colors.muted,
+                ],
+                widgetHeaderAlignment: "LEFT",
+            },
+            genieSpace: {
+                isEnabled: true,
+                enablementMode: "AUTO",
+            },
+        },
+    });
+}
+/** Create and publish a dashboard as the active OBO user. */
+export async function createGeneratorDashboard(input, signal) {
+    const identity = await resolveGeneratorIdentity();
+    if (identity.principal !== input.location.principal) {
+        throw new ExecutionError("Dashboard principal does not match the active OBO user");
+    }
+    const legacy = identity.userClient.toLegacyWorkspaceClient();
+    const parentPath = `/Workspace/Users/${identity.principal}/.dbx-tools/generator/${input.location.schema}`;
+    const context = signal ? databricks.toContext(signal) : undefined;
+    await legacy.workspace.mkdirs({ path: parentPath }, context);
+    const created = await legacy.lakeview.create({
+        dashboard: {
+            display_name: `${input.company} ${input.purpose} ${hash.id(6)}`,
+            parent_path: parentPath,
+            warehouse_id: input.warehouseId,
+            serialized_dashboard: JSON.stringify(buildGeneratorDashboard(input)),
+        },
+    }, context);
+    if (!created.dashboard_id) {
+        throw new ExecutionError("Lakeview create returned no dashboard id");
+    }
+    await legacy.lakeview.publish({
+        dashboard_id: created.dashboard_id,
+        warehouse_id: input.warehouseId,
+        embed_credentials: false,
+    }, context);
+    return GeneratedDashboardSchema.parse({
+        dashboardId: created.dashboard_id,
+        ...(created.path ? { path: created.path } : {}),
+        companionGenie: "AUTO",
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.js","sourceRoot":"","sources":["../../src/dashboard.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Deterministic AI/BI dashboard assembly and OBO publication.\n *\n * @module\n */\n\nimport { ExecutionError } from \"@databricks/appkit\";\nimport { databricks } from \"@dbx-tools/appkit\";\nimport { hash } from \"@dbx-tools/shared-core\";\nimport type { BrandContext } from \"@dbx-tools/shared-core/brand-utils\";\nimport {\n  GeneratedDashboardSchema,\n  type GeneratedDashboard,\n  type GeneratedMetric,\n  type GeneratedSchema,\n  type GeneratorPlan,\n} from \"@dbx-tools/shared-generator/workflow\";\nimport { z } from \"zod\";\nimport { resolveGeneratorIdentity } from \"./namespace.ts\";\n\nconst SerializedDashboardSchema = z\n  .object({\n    datasets: z.array(z.record(z.string(), z.unknown())).min(1),\n    pages: z.array(z.record(z.string(), z.unknown())).min(1),\n    uiSettings: z.record(z.string(), z.unknown()),\n  })\n  .strict();\n\n/** Inputs for dashboard assembly and publication. */\nexport interface CreateGeneratorDashboardInput {\n  /** Generated schema containing the fact table. */\n  location: GeneratedSchema;\n  /** Validated data and metric plan. */\n  plan: GeneratorPlan;\n  /** Brand applied to the dashboard theme. */\n  brand: BrandContext;\n  /** SQL warehouse used by the dashboard. */\n  warehouseId: string;\n  /** Company display name. */\n  company: string;\n  /** Demo purpose. */\n  purpose: string;\n}\n\n/** Compile one metric into a reusable Lakeview dataset measure. */\nfunction measure(metric: GeneratedMetric) {\n  const expression =\n    metric.aggregation === \"count\"\n      ? \"COUNT(`*`)\"\n      : `${metric.aggregation === \"sum\" ? \"SUM\" : \"AVG\"}(\\`${metric.column}\\`)`;\n  return {\n    displayName: metric.label,\n    description: metric.definition,\n    expression,\n  };\n}\n\n/** Counter widget bound to one dataset measure. */\nfunction counterWidget(metric: GeneratedMetric, index: number) {\n  const fieldName = `measure(${metric.label})`;\n  return {\n    widget: {\n      name: `kpi_${metric.name}`,\n      queries: [\n        {\n          name: \"main_query\",\n          query: {\n            datasetName: \"generated_facts\",\n            fields: [{ name: fieldName, expression: `MEASURE(\\`${metric.label}\\`)` }],\n            disaggregated: false,\n          },\n        },\n      ],\n      spec: {\n        version: 2,\n        widgetType: \"counter\",\n        encodings: {\n          value: {\n            fieldName,\n            displayName: metric.label,\n            ...(metric.unit === \"percent\"\n              ? {\n                  format: {\n                    type: \"number-percent\",\n                    decimalPlaces: { type: \"max\", places: 2 },\n                  },\n                }\n              : {}),\n          },\n        },\n        frame: { showTitle: true, title: metric.label },\n      },\n    },\n    position: {\n      x: (index % 3) * 4,\n      y: 2 + Math.floor(index / 3) * 3,\n      width: 4,\n      height: 3,\n    },\n  };\n}\n\n/** Build one complete dashboard with automatic companion Genie enabled. */\nexport function buildGeneratorDashboard(input: CreateGeneratorDashboardInput) {\n  const fullTable = `${input.location.catalog}.${input.location.schema}.${input.plan.table}`;\n  const dateColumn = input.plan.columns.find(({ generator }) => generator === \"date\")?.name;\n  const categoryColumn = input.plan.columns.find(({ generator }) => generator === \"category\")?.name;\n  const metric = input.plan.metrics[0]!;\n  const metricField = `measure(${metric.label})`;\n  const kpiRows = Math.ceil(input.plan.metrics.length / 3);\n  const chartY = 2 + kpiRows * 3;\n  const layout: Record<string, unknown>[] = [\n    {\n      widget: {\n        name: \"header\",\n        multilineTextboxSpec: {\n          lines: [`# ${input.company}: ${input.purpose}\\n`, `\\n`, input.plan.story],\n        },\n      },\n      position: { x: 0, y: 0, width: 12, height: 2 },\n    },\n    ...input.plan.metrics.map(counterWidget),\n  ];\n  if (dateColumn) {\n    layout.push({\n      widget: {\n        name: \"metric_trend\",\n        queries: [\n          {\n            name: \"main_query\",\n            query: {\n              datasetName: \"generated_facts\",\n              fields: [\n                {\n                  name: `daily(${dateColumn})`,\n                  expression: `DATE_TRUNC(\"DAY\", \\`${dateColumn}\\`)`,\n                },\n                { name: metricField, expression: `MEASURE(\\`${metric.label}\\`)` },\n              ],\n              disaggregated: false,\n            },\n          },\n        ],\n        spec: {\n          version: 3,\n          widgetType: \"line\",\n          encodings: {\n            x: {\n              fieldName: `daily(${dateColumn})`,\n              scale: { type: \"temporal\" },\n              displayName: \"Date\",\n            },\n            y: {\n              fieldName: metricField,\n              scale: { type: \"quantitative\" },\n              displayName: metric.label,\n            },\n          },\n          frame: { showTitle: true, title: `${metric.label} trend` },\n        },\n      },\n      position: { x: 0, y: chartY, width: 7, height: 6 },\n    });\n  }\n  if (categoryColumn) {\n    layout.push({\n      widget: {\n        name: \"metric_by_category\",\n        queries: [\n          {\n            name: \"main_query\",\n            query: {\n              datasetName: \"generated_facts\",\n              fields: [\n                { name: categoryColumn, expression: `\\`${categoryColumn}\\`` },\n                { name: metricField, expression: `MEASURE(\\`${metric.label}\\`)` },\n              ],\n              disaggregated: false,\n            },\n          },\n        ],\n        spec: {\n          version: 3,\n          widgetType: \"bar\",\n          encodings: {\n            x: {\n              fieldName: categoryColumn,\n              scale: { type: \"categorical\" },\n              displayName: categoryColumn,\n            },\n            y: {\n              fieldName: metricField,\n              scale: { type: \"quantitative\" },\n              displayName: metric.label,\n            },\n          },\n          frame: { showTitle: true, title: `${metric.label} by ${categoryColumn}` },\n        },\n      },\n      position: { x: 7, y: chartY, width: 5, height: 6 },\n    });\n  }\n  return SerializedDashboardSchema.parse({\n    datasets: [\n      {\n        name: \"generated_facts\",\n        displayName: input.plan.table,\n        asset_name: fullTable,\n        columns: input.plan.metrics.map(measure),\n      },\n    ],\n    pages: [\n      {\n        name: \"overview\",\n        displayName: \"Overview\",\n        pageType: \"PAGE_TYPE_CANVAS\",\n        layoutVersion: \"GRID_V1\",\n        layout,\n      },\n    ],\n    uiSettings: {\n      theme: {\n        canvasBackgroundColor: {\n          light: input.brand.colors.background,\n          dark: input.brand.colors.foreground,\n        },\n        widgetBackgroundColor: {\n          light: input.brand.colors.surface,\n          dark: input.brand.colors.primary,\n        },\n        fontColor: {\n          light: input.brand.colors.foreground,\n          dark: input.brand.colors.background,\n        },\n        selectionColor: {\n          light: input.brand.colors.primary,\n          dark: input.brand.colors.accent,\n        },\n        visualizationColors: [\n          input.brand.colors.primary,\n          input.brand.colors.accent,\n          input.brand.colors.primaryHover,\n          input.brand.colors.muted,\n        ],\n        widgetHeaderAlignment: \"LEFT\",\n      },\n      genieSpace: {\n        isEnabled: true,\n        enablementMode: \"AUTO\",\n      },\n    },\n  });\n}\n\n/** Create and publish a dashboard as the active OBO user. */\nexport async function createGeneratorDashboard(\n  input: CreateGeneratorDashboardInput,\n  signal?: AbortSignal,\n): Promise<GeneratedDashboard> {\n  const identity = await resolveGeneratorIdentity();\n  if (identity.principal !== input.location.principal) {\n    throw new ExecutionError(\"Dashboard principal does not match the active OBO user\");\n  }\n  const legacy = identity.userClient.toLegacyWorkspaceClient();\n  const parentPath = `/Workspace/Users/${identity.principal}/.dbx-tools/generator/${input.location.schema}`;\n  const context = signal ? databricks.toContext(signal) : undefined;\n  await legacy.workspace.mkdirs({ path: parentPath }, context);\n  const created = await legacy.lakeview.create(\n    {\n      dashboard: {\n        display_name: `${input.company} ${input.purpose} ${hash.id(6)}`,\n        parent_path: parentPath,\n        warehouse_id: input.warehouseId,\n        serialized_dashboard: JSON.stringify(buildGeneratorDashboard(input)),\n      },\n    },\n    context,\n  );\n  if (!created.dashboard_id) {\n    throw new ExecutionError(\"Lakeview create returned no dashboard id\");\n  }\n  await legacy.lakeview.publish(\n    {\n      dashboard_id: created.dashboard_id,\n      warehouse_id: input.warehouseId,\n      embed_credentials: false,\n    },\n    context,\n  );\n  return GeneratedDashboardSchema.parse({\n    dashboardId: created.dashboard_id,\n    ...(created.path ? { path: created.path } : {}),\n    companionGenie: \"AUTO\",\n  });\n}\n"]}

package/lib/src/data.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Deterministic Databricks SQL compilation, execution, and validation.
+ *
+ * @module
+ */
+import { type WorkspaceClient } from "@databricks/appkit";
+import type { GeneratedMetric, GeneratedSchema, GeneratorPlan, MaterializedGeneratorData } from "@dbx-tools/shared-generator/workflow";
+type StatementResponse = Awaited<ReturnType<WorkspaceClient["statementExecution"]["getStatement"]>>;
+/** Compile the generated table statement without accepting model-authored SQL. */
+export declare function compileGeneratorTableSql(location: GeneratedSchema, plan: GeneratorPlan): string;
+/** Compile one KPI validation query from its typed aggregate. */
+export declare function compileMetricValidationSql(table: string, metric: GeneratedMetric): string;
+/** Execute one statement and wait for its terminal response. */
+export declare function executeGeneratorStatement(client: WorkspaceClient, warehouseId: string, statement: string, location: Pick<GeneratedSchema, "catalog" | "schema">, signal?: AbortSignal): Promise<StatementResponse>;
+/** Materialize generated data as the OBO user and validate every planned KPI. */
+export declare function materializeGeneratorData(location: GeneratedSchema, plan: GeneratorPlan, warehouseId: string, signal?: AbortSignal): Promise<MaterializedGeneratorData>;
+export {};

package/lib/src/data.js

@@ -0,0 +1,114 @@
+/**
+ * Deterministic Databricks SQL compilation, execution, and validation.
+ *
+ * @module
+ */
+import { ExecutionError } from "@databricks/appkit";
+import { databricks } from "@dbx-tools/appkit";
+import { asyncUtils } from "@dbx-tools/shared-core";
+import { MaterializedGeneratorDataSchema } from "@dbx-tools/shared-generator/workflow";
+import { resolveGeneratorIdentity } from "./namespace.js";
+const TERMINAL_STATEMENT_STATES = new Set(["SUCCEEDED", "FAILED", "CANCELED", "CLOSED"]);
+/** Quote one already-validated SQL identifier. */
+function quoteIdentifier(value) {
+    return `\`${value.replaceAll("`", "``")}\``;
+}
+/** Quote one SQL string literal. */
+function quoteLiteral(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+/** Compile one safe column generator into a SQL expression. */
+function columnExpression(column) {
+    const salt = quoteLiteral(column.name);
+    switch (column.generator) {
+        case "id":
+            return `concat('ID-', lpad(cast(id as string), 8, '0'))`;
+        case "date":
+            return `date_sub(current_date(), pmod(xxhash64(id, ${salt}), ${column.days}))`;
+        case "category": {
+            const values = column.values.map(quoteLiteral);
+            const fallback = `element_at(array(${values.join(", ")}), pmod(xxhash64(id, ${salt}), ${values.length}) + 1)`;
+            return `case when pmod(xxhash64(id, ${salt}), 100) < 55 then ${values[0]} when pmod(xxhash64(id, ${salt}), 100) < 80 then ${values[1]} else ${fallback} end`;
+        }
+        case "number": {
+            const spread = column.maximum - column.minimum;
+            return `round((${column.minimum} + (pmod(xxhash64(id, ${salt}), 1000000) / 999999.0) * ${spread}) * case when pmod(xxhash64(id, ${salt}, 'anomaly'), 100) < 8 then 1.65 else 1 end, ${column.decimals})`;
+        }
+        case "boolean":
+            return `pmod(xxhash64(id, ${salt}), 10000) < ${Math.round(column.trueProbability * 10_000)}`;
+        default: {
+            const exhaustive = column;
+            throw new TypeError(`Unsupported generated column: ${String(exhaustive)}`);
+        }
+    }
+}
+/** Compile the generated table statement without accepting model-authored SQL. */
+export function compileGeneratorTableSql(location, plan) {
+    const columns = plan.columns.map((column) => `${columnExpression(column)} AS ${quoteIdentifier(column.name)}`);
+    return [
+        `CREATE OR REPLACE TABLE ${quoteIdentifier(location.catalog)}.${quoteIdentifier(location.schema)}.${quoteIdentifier(plan.table)}`,
+        `COMMENT ${quoteLiteral(plan.story)}`,
+        "AS SELECT",
+        `  ${columns.join(",\n  ")}`,
+        `FROM range(${plan.rowCount})`,
+    ].join("\n");
+}
+/** Compile one KPI validation query from its typed aggregate. */
+export function compileMetricValidationSql(table, metric) {
+    const aggregate = metric.aggregation === "count"
+        ? "count(*)"
+        : `${metric.aggregation === "sum" ? "sum" : "avg"}(${quoteIdentifier(metric.column)})`;
+    return `SELECT ${aggregate} AS ${quoteIdentifier(metric.name)} FROM ${table}`;
+}
+/** Execute one statement and wait for its terminal response. */
+export async function executeGeneratorStatement(client, warehouseId, statement, location, signal) {
+    const context = signal ? databricks.toContext(signal) : undefined;
+    let response = await client.statementExecution.executeStatement({
+        warehouse_id: warehouseId,
+        statement,
+        catalog: location.catalog,
+        schema: location.schema,
+        wait_timeout: "50s",
+        on_wait_timeout: "CONTINUE",
+    }, context);
+    if (!TERMINAL_STATEMENT_STATES.has(response.status?.state ?? "")) {
+        const statementId = response.statement_id;
+        if (!statementId)
+            throw new ExecutionError("Statement execution returned no statement id");
+        for await (const polled of asyncUtils.poll(({ signal: pollSignal }) => client.statementExecution.getStatement({ statement_id: statementId }, databricks.toContext(pollSignal)), {
+            intervalMs: 1_000,
+            timeoutMs: 180_000,
+            ...(signal ? { signal } : {}),
+            predicate: (value) => !TERMINAL_STATEMENT_STATES.has(value.status?.state ?? ""),
+        })) {
+            response = polled;
+        }
+    }
+    if (response.status?.state !== "SUCCEEDED") {
+        throw new ExecutionError(response.status?.error?.message ??
+            `Statement ended in ${response.status?.state ?? "UNKNOWN"}`);
+    }
+    return response;
+}
+/** Materialize generated data as the OBO user and validate every planned KPI. */
+export async function materializeGeneratorData(location, plan, warehouseId, signal) {
+    const identity = await resolveGeneratorIdentity();
+    if (identity.principal !== location.principal) {
+        throw new ExecutionError("Generator schema principal does not match the active OBO user");
+    }
+    await executeGeneratorStatement(identity.userClient, warehouseId, compileGeneratorTableSql(location, plan), location, signal);
+    const fullTable = `${location.catalog}.${location.schema}.${plan.table}`;
+    const validationStatements = {};
+    for (const metric of plan.metrics) {
+        const response = await executeGeneratorStatement(identity.userClient, warehouseId, compileMetricValidationSql(fullTable, metric), location, signal);
+        if (!response.statement_id) {
+            throw new ExecutionError(`Validation for ${metric.name} returned no statement id`);
+        }
+        validationStatements[metric.name] = response.statement_id;
+    }
+    return MaterializedGeneratorDataSchema.parse({
+        tables: [fullTable],
+        validationStatements,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data.js","sourceRoot":"","sources":["../../src/data.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Deterministic Databricks SQL compilation, execution, and validation.\n *\n * @module\n */\n\nimport { ExecutionError, type WorkspaceClient } from \"@databricks/appkit\";\nimport { databricks } from \"@dbx-tools/appkit\";\nimport { asyncUtils } from \"@dbx-tools/shared-core\";\nimport { MaterializedGeneratorDataSchema } from \"@dbx-tools/shared-generator/workflow\";\nimport type {\n  GeneratedColumn,\n  GeneratedMetric,\n  GeneratedSchema,\n  GeneratorPlan,\n  MaterializedGeneratorData,\n} from \"@dbx-tools/shared-generator/workflow\";\nimport { resolveGeneratorIdentity } from \"./namespace.ts\";\n\nconst TERMINAL_STATEMENT_STATES = new Set([\"SUCCEEDED\", \"FAILED\", \"CANCELED\", \"CLOSED\"]);\ntype StatementResponse = Awaited<ReturnType<WorkspaceClient[\"statementExecution\"][\"getStatement\"]>>;\n\n/** Quote one already-validated SQL identifier. */\nfunction quoteIdentifier(value: string): string {\n  return `\\`${value.replaceAll(\"`\", \"``\")}\\``;\n}\n\n/** Quote one SQL string literal. */\nfunction quoteLiteral(value: string): string {\n  return `'${value.replaceAll(\"'\", \"''\")}'`;\n}\n\n/** Compile one safe column generator into a SQL expression. */\nfunction columnExpression(column: GeneratedColumn): string {\n  const salt = quoteLiteral(column.name);\n  switch (column.generator) {\n    case \"id\":\n      return `concat('ID-', lpad(cast(id as string), 8, '0'))`;\n    case \"date\":\n      return `date_sub(current_date(), pmod(xxhash64(id, ${salt}), ${column.days}))`;\n    case \"category\": {\n      const values = column.values.map(quoteLiteral);\n      const fallback = `element_at(array(${values.join(\", \")}), pmod(xxhash64(id, ${salt}), ${values.length}) + 1)`;\n      return `case when pmod(xxhash64(id, ${salt}), 100) < 55 then ${values[0]} when pmod(xxhash64(id, ${salt}), 100) < 80 then ${values[1]} else ${fallback} end`;\n    }\n    case \"number\": {\n      const spread = column.maximum - column.minimum;\n      return `round((${column.minimum} + (pmod(xxhash64(id, ${salt}), 1000000) / 999999.0) * ${spread}) * case when pmod(xxhash64(id, ${salt}, 'anomaly'), 100) < 8 then 1.65 else 1 end, ${column.decimals})`;\n    }\n    case \"boolean\":\n      return `pmod(xxhash64(id, ${salt}), 10000) < ${Math.round(column.trueProbability * 10_000)}`;\n    default: {\n      const exhaustive: never = column;\n      throw new TypeError(`Unsupported generated column: ${String(exhaustive)}`);\n    }\n  }\n}\n\n/** Compile the generated table statement without accepting model-authored SQL. */\nexport function compileGeneratorTableSql(location: GeneratedSchema, plan: GeneratorPlan): string {\n  const columns = plan.columns.map(\n    (column) => `${columnExpression(column)} AS ${quoteIdentifier(column.name)}`,\n  );\n  return [\n    `CREATE OR REPLACE TABLE ${quoteIdentifier(location.catalog)}.${quoteIdentifier(location.schema)}.${quoteIdentifier(plan.table)}`,\n    `COMMENT ${quoteLiteral(plan.story)}`,\n    \"AS SELECT\",\n    `  ${columns.join(\",\\n  \")}`,\n    `FROM range(${plan.rowCount})`,\n  ].join(\"\\n\");\n}\n\n/** Compile one KPI validation query from its typed aggregate. */\nexport function compileMetricValidationSql(table: string, metric: GeneratedMetric): string {\n  const aggregate =\n    metric.aggregation === \"count\"\n      ? \"count(*)\"\n      : `${metric.aggregation === \"sum\" ? \"sum\" : \"avg\"}(${quoteIdentifier(metric.column!)})`;\n  return `SELECT ${aggregate} AS ${quoteIdentifier(metric.name)} FROM ${table}`;\n}\n\n/** Execute one statement and wait for its terminal response. */\nexport async function executeGeneratorStatement(\n  client: WorkspaceClient,\n  warehouseId: string,\n  statement: string,\n  location: Pick<GeneratedSchema, \"catalog\" | \"schema\">,\n  signal?: AbortSignal,\n): Promise<StatementResponse> {\n  const context = signal ? databricks.toContext(signal) : undefined;\n  let response = await client.statementExecution.executeStatement(\n    {\n      warehouse_id: warehouseId,\n      statement,\n      catalog: location.catalog,\n      schema: location.schema,\n      wait_timeout: \"50s\",\n      on_wait_timeout: \"CONTINUE\",\n    },\n    context,\n  );\n  if (!TERMINAL_STATEMENT_STATES.has(response.status?.state ?? \"\")) {\n    const statementId = response.statement_id;\n    if (!statementId) throw new ExecutionError(\"Statement execution returned no statement id\");\n    for await (const polled of asyncUtils.poll<StatementResponse>(\n      ({ signal: pollSignal }) =>\n        client.statementExecution.getStatement(\n          { statement_id: statementId },\n          databricks.toContext(pollSignal),\n        ),\n      {\n        intervalMs: 1_000,\n        timeoutMs: 180_000,\n        ...(signal ? { signal } : {}),\n        predicate: (value) => !TERMINAL_STATEMENT_STATES.has(value.status?.state ?? \"\"),\n      },\n    )) {\n      response = polled;\n    }\n  }\n  if (response.status?.state !== \"SUCCEEDED\") {\n    throw new ExecutionError(\n      response.status?.error?.message ??\n        `Statement ended in ${response.status?.state ?? \"UNKNOWN\"}`,\n    );\n  }\n  return response;\n}\n\n/** Materialize generated data as the OBO user and validate every planned KPI. */\nexport async function materializeGeneratorData(\n  location: GeneratedSchema,\n  plan: GeneratorPlan,\n  warehouseId: string,\n  signal?: AbortSignal,\n): Promise<MaterializedGeneratorData> {\n  const identity = await resolveGeneratorIdentity();\n  if (identity.principal !== location.principal) {\n    throw new ExecutionError(\"Generator schema principal does not match the active OBO user\");\n  }\n  await executeGeneratorStatement(\n    identity.userClient,\n    warehouseId,\n    compileGeneratorTableSql(location, plan),\n    location,\n    signal,\n  );\n  const fullTable = `${location.catalog}.${location.schema}.${plan.table}`;\n  const validationStatements: Record<string, string> = {};\n  for (const metric of plan.metrics) {\n    const response = await executeGeneratorStatement(\n      identity.userClient,\n      warehouseId,\n      compileMetricValidationSql(fullTable, metric),\n      location,\n      signal,\n    );\n    if (!response.statement_id) {\n      throw new ExecutionError(`Validation for ${metric.name} returned no statement id`);\n    }\n    validationStatements[metric.name] = response.statement_id;\n  }\n  return MaterializedGeneratorDataSchema.parse({\n    tables: [fullTable],\n    validationStatements,\n  });\n}\n"]}

package/lib/src/defaults.d.ts

@@ -0,0 +1,39 @@
+/**
+ * AppKit interceptor settings for researched brand generation.
+ *
+ * @module
+ */
+import { type BrandGenerationRequest } from "./schema.ts";
+/** AppKit execute configuration used by this package. */
+export type BrandExecuteConfig = {
+    cache?: {
+        enabled?: boolean;
+        ttl?: number;
+        cacheKey?: (string | number | object)[];
+    };
+    retry?: {
+        enabled?: boolean;
+        attempts?: number;
+        initialDelay?: number;
+        maxDelay?: number;
+    };
+    timeout?: number;
+};
+/** Execution settings accepted by `Plugin.execute()`. */
+export type BrandExecutionSettings = {
+    default: BrandExecuteConfig;
+    user?: BrandExecuteConfig;
+};
+/** Cache lifetime for a generated branding package. */
+export declare const BRAND_CACHE_TTL_SECONDS = 21600;
+/** Cache-key version for the generated package shape and asset policy. */
+export declare const BRAND_CACHE_VERSION = 5;
+/** Attempts for the idempotent structured synthesis call. */
+export declare const BRAND_GENERATION_ATTEMPTS = 2;
+/** Build request-specific interceptor settings for brand generation. */
+export declare function brandGenerationSettings(request: BrandGenerationRequest, options: {
+    timeoutMs: number;
+    model?: string;
+    maxSources: number;
+    sourceMaxLength: number;
+}): BrandExecutionSettings;

package/lib/src/defaults.js

@@ -0,0 +1,36 @@
+/**
+ * AppKit interceptor settings for researched brand generation.
+ *
+ * @module
+ */
+import { brandRequestSubject } from "./schema.js";
+/** Cache lifetime for a generated branding package. */
+export const BRAND_CACHE_TTL_SECONDS = 21_600;
+/** Cache-key version for the generated package shape and asset policy. */
+export const BRAND_CACHE_VERSION = 5;
+/** Attempts for the idempotent structured synthesis call. */
+export const BRAND_GENERATION_ATTEMPTS = 2;
+/** Build request-specific interceptor settings for brand generation. */
+export function brandGenerationSettings(request, options) {
+    return {
+        default: {
+            cache: {
+                enabled: true,
+                ttl: BRAND_CACHE_TTL_SECONDS,
+                cacheKey: [
+                    "brand",
+                    "generate",
+                    BRAND_CACHE_VERSION,
+                    brandRequestSubject(request).toLowerCase(),
+                    request.website ?? "",
+                    options.model ?? "",
+                    options.maxSources,
+                    options.sourceMaxLength,
+                ],
+            },
+            retry: { enabled: true, attempts: BRAND_GENERATION_ATTEMPTS },
+            timeout: options.timeoutMs,
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/generate.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Evidence-backed generation of the portable shared brand context.
+ *
+ * @module
+ */
+import type { WorkspaceClient } from "@databricks/appkit";
+import { type BrandProgressReporter, type BrandResearch, type BrandResearchClient } from "./research.ts";
+import { type BrandGenerationRequest, type BrandPackage, type GeneratedBrandProfile } from "./schema.ts";
+/** Inputs passed to a structured brand-profile synthesizer. */
+export interface BrandSynthesisInput {
+    /** Validated brand request. */
+    request: BrandGenerationRequest;
+    /** Search summary and fetched page evidence. */
+    research: BrandResearch;
+    /** Optional synthesis-model preference. */
+    model?: string;
+    /** Explicit workspace client for standalone callers. */
+    workspaceClient?: WorkspaceClient;
+}
+/** Replaceable structured synthesis boundary used by tests and custom runtimes. */
+export type BrandSynthesizer = (input: BrandSynthesisInput, signal?: AbortSignal) => Promise<GeneratedBrandProfile>;
+/** Options for one complete brand-generation workflow. */
+export interface GenerateBrandPackageOptions {
+    /** Search and fetch operations from the registered web-search plugin. */
+    client: BrandResearchClient;
+    /** Optional synthesis-model preference. */
+    model?: string;
+    /** Maximum cited pages fetched per brand. */
+    maxSources?: number;
+    /** Maximum readable characters retained from each fetched page. */
+    sourceMaxLength?: number;
+    /** Custom structured synthesizer. Defaults to the AppKit model resolver. */
+    synthesize?: BrandSynthesizer;
+    /** Receives observable workflow progress. */
+    onProgress?: BrandProgressReporter;
+    /** Receives fetched research for exporters that persist visual references. */
+    onResearch?: (research: BrandResearch) => void | Promise<void>;
+    /** Explicit workspace client for standalone model resolution. */
+    workspaceClient?: WorkspaceClient;
+}
+/** Instructions applied outside the untrusted page-content prompt. */
+export declare const BRAND_SYNTHESIS_INSTRUCTIONS: string;
+/** Format bounded research evidence as the model's data-only prompt. */
+export declare function brandSynthesisPrompt(input: BrandSynthesisInput): string;
+/** Synthesize the evidence into the required brand-profile contract. */
+export declare function synthesizeBrandProfile(input: BrandSynthesisInput, signal?: AbortSignal): Promise<GeneratedBrandProfile>;
+/**
+ * Search and fetch official sources, synthesize a structured profile, and
+ * attach deterministic page-discovered artwork as a portable BrandContext.
+ */
+export declare function generateBrandPackage(input: BrandGenerationRequest, options: GenerateBrandPackageOptions, signal?: AbortSignal): Promise<BrandPackage>;