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

package/lib/src/namespace.js

@@ -0,0 +1,119 @@
+/**
+ * Per-user Unity Catalog namespace derivation and provisioning.
+ *
+ * @module
+ */
+import { ConfigurationError, createWorkspaceClient, getExecutionContext, } from "@databricks/appkit";
+import { databricks } from "@dbx-tools/appkit";
+import { errorUtils, hash, stringUtils } from "@dbx-tools/shared-core";
+import { GeneratedSchemaSchema, } from "@dbx-tools/shared-generator/workflow";
+const OWNER_DIGEST_PROPERTY = "dbx_tools.generator.owner_digest";
+const REQUEST_DIGEST_PROPERTY = "dbx_tools.generator.request_digest";
+/** Derive a readable, bounded schema name with collision-resistant overflow. */
+export function generatorSchemaName(principal, company, purpose) {
+    const base = stringUtils.toIdentifierWithOptions({
+        delimiter: "_",
+        omitEmailDomain: true,
+        maxLength: 96,
+        truncateStrategy: "hash",
+        truncateHashLength: 8,
+    }, principal, company, purpose);
+    return /^[a-z]/.test(base) ? base : `u_${base}`;
+}
+/** Resolve the active OBO caller and a separate app service-principal client. */
+export async function resolveGeneratorIdentity() {
+    const context = getExecutionContext();
+    if (!("userId" in context)) {
+        throw new ConfigurationError("Generator operations require an on-behalf-of user context");
+    }
+    const current = await context.client.currentUser.me();
+    const principal = stringUtils.trimToNull(current.userName);
+    if (!principal) {
+        throw new ConfigurationError("The current Databricks user has no userName");
+    }
+    return {
+        userClient: context.client,
+        serviceClient: createWorkspaceClient(),
+        principal,
+        userId: context.userId,
+    };
+}
+/** Return an existing schema, treating only a genuine not-found response as absent. */
+async function getSchema(client, fullName) {
+    try {
+        return await client.toLegacyWorkspaceClient().schemas.get({ full_name: fullName });
+    }
+    catch (cause) {
+        const context = errorUtils.errorContext(cause);
+        if (context.hasStatusCode(404) || context.hasMessage("does not exist"))
+            return undefined;
+        throw cause;
+    }
+}
+/** Verify that an existing deterministic schema belongs to this user and request. */
+function assertSchemaMarkers(schema, ownerDigest, requestDigest, fullName) {
+    if (schema.properties?.[OWNER_DIGEST_PROPERTY] !== ownerDigest ||
+        schema.properties?.[REQUEST_DIGEST_PROPERTY] !== requestDigest) {
+        throw new ConfigurationError(`Generator schema ${fullName} already exists with different ownership markers`);
+    }
+}
+/**
+ * Check-create-recheck one marked schema as the app service principal, then
+ * grant the OBO user full schema control while retaining SP ownership.
+ */
+export async function provisionGeneratorSchema(input, signal) {
+    const identity = await resolveGeneratorIdentity();
+    return provisionGeneratorSchemaWithIdentity(input, identity, signal);
+}
+/** Provision with explicit trusted clients, for plugin reuse and isolated tests. */
+export async function provisionGeneratorSchemaWithIdentity(input, identity, signal) {
+    const catalog = stringUtils.trimToNull(input.catalog);
+    if (!catalog)
+        throw new ConfigurationError("GENERATOR_CATALOG is required");
+    const schemaName = generatorSchemaName(identity.principal, input.request.company, input.request.purpose);
+    const fullName = `${catalog}.${schemaName}`;
+    const ownerDigest = hash.fnvHash(identity.userId);
+    const requestDigest = hash.fnvHash(identity.userId, input.request.company, input.request.purpose);
+    const context = signal ? databricks.toContext(signal) : undefined;
+    await identity.userClient.toLegacyWorkspaceClient().catalogs.get({ name: catalog });
+    let schema = await getSchema(identity.serviceClient, fullName);
+    if (!schema) {
+        try {
+            await identity.serviceClient.toLegacyWorkspaceClient().schemas.create({
+                catalog_name: catalog,
+                name: schemaName,
+                comment: `Generated demo assets for ${identity.principal}`,
+                properties: {
+                    [OWNER_DIGEST_PROPERTY]: ownerDigest,
+                    [REQUEST_DIGEST_PROPERTY]: requestDigest,
+                },
+            }, context);
+        }
+        catch (cause) {
+            if (!errorUtils.errorContext(cause).hasMessage("already exists"))
+                throw cause;
+        }
+        schema = await getSchema(identity.serviceClient, fullName);
+    }
+    if (!schema) {
+        throw ConfigurationError.resourceNotFound("Generator schema", fullName);
+    }
+    assertSchemaMarkers(schema, ownerDigest, requestDigest, fullName);
+    await identity.serviceClient.toLegacyWorkspaceClient().grants.update({
+        securable_type: "SCHEMA",
+        full_name: fullName,
+        changes: [
+            {
+                principal: identity.principal,
+                add: ["ALL_PRIVILEGES", "MANAGE"],
+            },
+        ],
+    }, context);
+    return GeneratedSchemaSchema.parse({
+        catalog,
+        schema: schemaName,
+        fullName,
+        principal: identity.principal,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"namespace.js","sourceRoot":"","sources":["../../src/namespace.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Per-user Unity Catalog namespace derivation and provisioning.\n *\n * @module\n */\n\nimport {\n  ConfigurationError,\n  createWorkspaceClient,\n  getExecutionContext,\n  type WorkspaceClient,\n} from \"@databricks/appkit\";\nimport { databricks } from \"@dbx-tools/appkit\";\nimport { errorUtils, hash, stringUtils } from \"@dbx-tools/shared-core\";\nimport {\n  GeneratedSchemaSchema,\n  type GeneratedSchema,\n  type GeneratorRequest,\n} from \"@dbx-tools/shared-generator/workflow\";\n\nconst OWNER_DIGEST_PROPERTY = \"dbx_tools.generator.owner_digest\";\nconst REQUEST_DIGEST_PROPERTY = \"dbx_tools.generator.request_digest\";\n\n/** Inputs needed to provision one deterministic generated schema. */\nexport interface ProvisionSchemaInput {\n  /** Configured parent catalog. */\n  catalog: string;\n  /** Company and purpose used to derive the schema name. */\n  request: Pick<GeneratorRequest, \"company\" | \"purpose\">;\n}\n\n/** Trusted user identity and clients resolved from the active AppKit request. */\nexport interface GeneratorIdentity {\n  /** OBO workspace client. */\n  userClient: WorkspaceClient;\n  /** Service-principal workspace client. */\n  serviceClient: WorkspaceClient;\n  /** Trusted Databricks user name. */\n  principal: string;\n  /** Trusted stable user id. */\n  userId: string;\n}\n\n/** Derive a readable, bounded schema name with collision-resistant overflow. */\nexport function generatorSchemaName(principal: string, company: string, purpose: string): string {\n  const base = stringUtils.toIdentifierWithOptions(\n    {\n      delimiter: \"_\",\n      omitEmailDomain: true,\n      maxLength: 96,\n      truncateStrategy: \"hash\",\n      truncateHashLength: 8,\n    },\n    principal,\n    company,\n    purpose,\n  );\n  return /^[a-z]/.test(base) ? base : `u_${base}`;\n}\n\n/** Resolve the active OBO caller and a separate app service-principal client. */\nexport async function resolveGeneratorIdentity(): Promise<GeneratorIdentity> {\n  const context = getExecutionContext();\n  if (!(\"userId\" in context)) {\n    throw new ConfigurationError(\"Generator operations require an on-behalf-of user context\");\n  }\n  const current = await context.client.currentUser.me();\n  const principal = stringUtils.trimToNull(current.userName);\n  if (!principal) {\n    throw new ConfigurationError(\"The current Databricks user has no userName\");\n  }\n  return {\n    userClient: context.client,\n    serviceClient: createWorkspaceClient(),\n    principal,\n    userId: context.userId,\n  };\n}\n\n/** Return an existing schema, treating only a genuine not-found response as absent. */\nasync function getSchema(\n  client: WorkspaceClient,\n  fullName: string,\n): Promise<\n  | Awaited<ReturnType<ReturnType<WorkspaceClient[\"toLegacyWorkspaceClient\"]>[\"schemas\"][\"get\"]>>\n  | undefined\n> {\n  try {\n    return await client.toLegacyWorkspaceClient().schemas.get({ full_name: fullName });\n  } catch (cause) {\n    const context = errorUtils.errorContext(cause);\n    if (context.hasStatusCode(404) || context.hasMessage(\"does not exist\")) return undefined;\n    throw cause;\n  }\n}\n\n/** Verify that an existing deterministic schema belongs to this user and request. */\nfunction assertSchemaMarkers(\n  schema: { properties?: Record<string, string> },\n  ownerDigest: string,\n  requestDigest: string,\n  fullName: string,\n): void {\n  if (\n    schema.properties?.[OWNER_DIGEST_PROPERTY] !== ownerDigest ||\n    schema.properties?.[REQUEST_DIGEST_PROPERTY] !== requestDigest\n  ) {\n    throw new ConfigurationError(\n      `Generator schema ${fullName} already exists with different ownership markers`,\n    );\n  }\n}\n\n/**\n * Check-create-recheck one marked schema as the app service principal, then\n * grant the OBO user full schema control while retaining SP ownership.\n */\nexport async function provisionGeneratorSchema(\n  input: ProvisionSchemaInput,\n  signal?: AbortSignal,\n): Promise<GeneratedSchema> {\n  const identity = await resolveGeneratorIdentity();\n  return provisionGeneratorSchemaWithIdentity(input, identity, signal);\n}\n\n/** Provision with explicit trusted clients, for plugin reuse and isolated tests. */\nexport async function provisionGeneratorSchemaWithIdentity(\n  input: ProvisionSchemaInput,\n  identity: GeneratorIdentity,\n  signal?: AbortSignal,\n): Promise<GeneratedSchema> {\n  const catalog = stringUtils.trimToNull(input.catalog);\n  if (!catalog) throw new ConfigurationError(\"GENERATOR_CATALOG is required\");\n\n  const schemaName = generatorSchemaName(\n    identity.principal,\n    input.request.company,\n    input.request.purpose,\n  );\n  const fullName = `${catalog}.${schemaName}`;\n  const ownerDigest = hash.fnvHash(identity.userId);\n  const requestDigest = hash.fnvHash(identity.userId, input.request.company, input.request.purpose);\n  const context = signal ? databricks.toContext(signal) : undefined;\n\n  await identity.userClient.toLegacyWorkspaceClient().catalogs.get({ name: catalog });\n\n  let schema = await getSchema(identity.serviceClient, fullName);\n  if (!schema) {\n    try {\n      await identity.serviceClient.toLegacyWorkspaceClient().schemas.create(\n        {\n          catalog_name: catalog,\n          name: schemaName,\n          comment: `Generated demo assets for ${identity.principal}`,\n          properties: {\n            [OWNER_DIGEST_PROPERTY]: ownerDigest,\n            [REQUEST_DIGEST_PROPERTY]: requestDigest,\n          },\n        },\n        context,\n      );\n    } catch (cause) {\n      if (!errorUtils.errorContext(cause).hasMessage(\"already exists\")) throw cause;\n    }\n    schema = await getSchema(identity.serviceClient, fullName);\n  }\n  if (!schema) {\n    throw ConfigurationError.resourceNotFound(\"Generator schema\", fullName);\n  }\n  assertSchemaMarkers(schema, ownerDigest, requestDigest, fullName);\n\n  await identity.serviceClient.toLegacyWorkspaceClient().grants.update(\n    {\n      securable_type: \"SCHEMA\",\n      full_name: fullName,\n      changes: [\n        {\n          principal: identity.principal,\n          add: [\"ALL_PRIVILEGES\", \"MANAGE\"],\n        },\n      ],\n    },\n    context,\n  );\n\n  return GeneratedSchemaSchema.parse({\n    catalog,\n    schema: schemaName,\n    fullName,\n    principal: identity.principal,\n  });\n}\n"]}

package/lib/src/operations.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Reusable generator operations shared by tools and workflow steps.
+ *
+ * @module
+ */
+import type { BrandGenerationRequest, BrandPackage } from "@dbx-tools/shared-generator/brand";
+import type { KpiResearchRequest, KpiResearchResult } from "@dbx-tools/shared-generator/kpi";
+import type { CreateGeneratorPresentationRequest, GeneratedDashboard, GeneratedGenieSpace, GeneratedSchema, GeneratorPlan, MaterializeGeneratorDataRequest, MaterializedGeneratorData, PlanGeneratorDataRequest, ProvisionGeneratorSchemaRequest } from "@dbx-tools/shared-generator/workflow";
+import type { ResolvedGeneratorConfig } from "./config.ts";
+import type { BrandProgressReporter, BrandResearchClient } from "./research.ts";
+/** Runtime dependencies captured by one generator plugin instance. */
+export interface GeneratorOperationsOptions {
+    /** Resolved generator configuration. */
+    config: ResolvedGeneratorConfig;
+    /** Registered web-search plugin operations. */
+    researchClient: BrandResearchClient;
+}
+/** One behavior owner for every generator tool and workflow step. */
+export declare class GeneratorOperations {
+    private readonly config;
+    private readonly researchClient;
+    /** Create operations over one isolated plugin runtime. */
+    constructor(options: GeneratorOperationsOptions);
+    /** Generate portable brand assets without KPI research or Databricks writes. */
+    generateBrand(request: BrandGenerationRequest, signal?: AbortSignal, onProgress?: BrandProgressReporter): Promise<BrandPackage>;
+    /** Research KPIs independently of any mutation workflow. */
+    researchKpis(request: KpiResearchRequest, signal?: AbortSignal): Promise<KpiResearchResult>;
+    /** Build a typed deterministic data plan. */
+    planData(request: PlanGeneratorDataRequest, signal?: AbortSignal): Promise<GeneratorPlan>;
+    /** Provision the active OBO user's deterministic schema. */
+    provisionSchema(request: ProvisionGeneratorSchemaRequest, signal?: AbortSignal): Promise<GeneratedSchema>;
+    /** Materialize generated data and validate its KPI aggregates. */
+    materializeData(request: MaterializeGeneratorDataRequest, signal?: AbortSignal): Promise<MaterializedGeneratorData>;
+    /** Create and publish a dashboard with automatic companion Genie. */
+    createDashboard(request: CreateGeneratorPresentationRequest, signal?: AbortSignal): Promise<GeneratedDashboard>;
+    /** Create a standalone Genie space for no-dashboard runs. */
+    createGenie(request: CreateGeneratorPresentationRequest, signal?: AbortSignal): Promise<GeneratedGenieSpace>;
+    /** Configured catalog or a deployment-time configuration error. */
+    private requiredCatalog;
+    /** Configured SQL warehouse or a deployment-time configuration error. */
+    private requiredWarehouseId;
+}

package/lib/src/operations.js

@@ -0,0 +1,96 @@
+/**
+ * Reusable generator operations shared by tools and workflow steps.
+ *
+ * @module
+ */
+import { ConfigurationError } from "@databricks/appkit";
+import { createGeneratorDashboard } from "./dashboard.js";
+import { materializeGeneratorData } from "./data.js";
+import { generateBrandPackage } from "./generate.js";
+import { createGeneratorGenieSpace } from "./genie.js";
+import { researchKpis } from "./kpi.js";
+import { provisionGeneratorSchema } from "./namespace.js";
+import { planGeneratorData } from "./plan.js";
+/** One behavior owner for every generator tool and workflow step. */
+export class GeneratorOperations {
+    config;
+    researchClient;
+    /** Create operations over one isolated plugin runtime. */
+    constructor(options) {
+        this.config = options.config;
+        this.researchClient = options.researchClient;
+    }
+    /** Generate portable brand assets without KPI research or Databricks writes. */
+    generateBrand(request, signal, onProgress) {
+        return generateBrandPackage(request, {
+            client: this.researchClient,
+            ...(this.config.model ? { model: this.config.model } : {}),
+            maxSources: this.config.maxSources,
+            sourceMaxLength: this.config.sourceMaxLength,
+            ...(onProgress ? { onProgress } : {}),
+        }, signal);
+    }
+    /** Research KPIs independently of any mutation workflow. */
+    researchKpis(request, signal) {
+        return researchKpis(request, {
+            client: this.researchClient,
+            maxSources: this.config.maxSources,
+            sourceMaxLength: this.config.sourceMaxLength,
+            ...(this.config.model ? { model: this.config.model } : {}),
+        }, signal);
+    }
+    /** Build a typed deterministic data plan. */
+    planData(request, signal) {
+        return planGeneratorData({
+            ...request,
+            ...(this.config.model ? { model: this.config.model } : {}),
+        }, signal);
+    }
+    /** Provision the active OBO user's deterministic schema. */
+    provisionSchema(request, signal) {
+        return provisionGeneratorSchema({
+            catalog: this.requiredCatalog(),
+            request: request.request,
+        }, signal);
+    }
+    /** Materialize generated data and validate its KPI aggregates. */
+    materializeData(request, signal) {
+        return materializeGeneratorData(request.location, request.plan, this.requiredWarehouseId(), signal);
+    }
+    /** Create and publish a dashboard with automatic companion Genie. */
+    createDashboard(request, signal) {
+        return createGeneratorDashboard({
+            location: request.location,
+            plan: request.plan,
+            brand: request.brand.brand,
+            company: request.request.company,
+            purpose: request.request.purpose,
+            warehouseId: this.requiredWarehouseId(),
+        }, signal);
+    }
+    /** Create a standalone Genie space for no-dashboard runs. */
+    createGenie(request, signal) {
+        return createGeneratorGenieSpace({
+            location: request.location,
+            plan: request.plan,
+            company: request.request.company,
+            purpose: request.request.purpose,
+            warehouseId: this.requiredWarehouseId(),
+        }, signal);
+    }
+    /** Configured catalog or a deployment-time configuration error. */
+    requiredCatalog() {
+        if (!this.config.catalog) {
+            throw new ConfigurationError("GENERATOR_CATALOG is required for generator mutations");
+        }
+        return this.config.catalog;
+    }
+    /** Configured SQL warehouse or a deployment-time configuration error. */
+    requiredWarehouseId() {
+        if (!this.config.warehouseId) {
+            throw new ConfigurationError("DATABRICKS_WAREHOUSE_ID is required for generator mutations");
+        }
+        return this.config.warehouseId;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operations.js","sourceRoot":"","sources":["../../src/operations.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Reusable generator operations shared by tools and workflow steps.\n *\n * @module\n */\n\nimport { ConfigurationError } from \"@databricks/appkit\";\nimport type { BrandGenerationRequest, BrandPackage } from \"@dbx-tools/shared-generator/brand\";\nimport type { KpiResearchRequest, KpiResearchResult } from \"@dbx-tools/shared-generator/kpi\";\nimport type {\n  CreateGeneratorPresentationRequest,\n  GeneratedDashboard,\n  GeneratedGenieSpace,\n  GeneratedSchema,\n  GeneratorPlan,\n  MaterializeGeneratorDataRequest,\n  MaterializedGeneratorData,\n  PlanGeneratorDataRequest,\n  ProvisionGeneratorSchemaRequest,\n} from \"@dbx-tools/shared-generator/workflow\";\nimport type { ResolvedGeneratorConfig } from \"./config.ts\";\nimport { createGeneratorDashboard } from \"./dashboard.ts\";\nimport { materializeGeneratorData } from \"./data.ts\";\nimport { generateBrandPackage } from \"./generate.ts\";\nimport { createGeneratorGenieSpace } from \"./genie.ts\";\nimport { researchKpis } from \"./kpi.ts\";\nimport { provisionGeneratorSchema } from \"./namespace.ts\";\nimport { planGeneratorData } from \"./plan.ts\";\nimport type { BrandProgressReporter, BrandResearchClient } from \"./research.ts\";\n\n/** Runtime dependencies captured by one generator plugin instance. */\nexport interface GeneratorOperationsOptions {\n  /** Resolved generator configuration. */\n  config: ResolvedGeneratorConfig;\n  /** Registered web-search plugin operations. */\n  researchClient: BrandResearchClient;\n}\n\n/** One behavior owner for every generator tool and workflow step. */\nexport class GeneratorOperations {\n  private readonly config: ResolvedGeneratorConfig;\n  private readonly researchClient: BrandResearchClient;\n\n  /** Create operations over one isolated plugin runtime. */\n  constructor(options: GeneratorOperationsOptions) {\n    this.config = options.config;\n    this.researchClient = options.researchClient;\n  }\n\n  /** Generate portable brand assets without KPI research or Databricks writes. */\n  generateBrand(\n    request: BrandGenerationRequest,\n    signal?: AbortSignal,\n    onProgress?: BrandProgressReporter,\n  ): Promise<BrandPackage> {\n    return generateBrandPackage(\n      request,\n      {\n        client: this.researchClient,\n        ...(this.config.model ? { model: this.config.model } : {}),\n        maxSources: this.config.maxSources,\n        sourceMaxLength: this.config.sourceMaxLength,\n        ...(onProgress ? { onProgress } : {}),\n      },\n      signal,\n    );\n  }\n\n  /** Research KPIs independently of any mutation workflow. */\n  researchKpis(request: KpiResearchRequest, signal?: AbortSignal): Promise<KpiResearchResult> {\n    return researchKpis(\n      request,\n      {\n        client: this.researchClient,\n        maxSources: this.config.maxSources,\n        sourceMaxLength: this.config.sourceMaxLength,\n        ...(this.config.model ? { model: this.config.model } : {}),\n      },\n      signal,\n    );\n  }\n\n  /** Build a typed deterministic data plan. */\n  planData(request: PlanGeneratorDataRequest, signal?: AbortSignal): Promise<GeneratorPlan> {\n    return planGeneratorData(\n      {\n        ...request,\n        ...(this.config.model ? { model: this.config.model } : {}),\n      },\n      signal,\n    );\n  }\n\n  /** Provision the active OBO user's deterministic schema. */\n  provisionSchema(\n    request: ProvisionGeneratorSchemaRequest,\n    signal?: AbortSignal,\n  ): Promise<GeneratedSchema> {\n    return provisionGeneratorSchema(\n      {\n        catalog: this.requiredCatalog(),\n        request: request.request,\n      },\n      signal,\n    );\n  }\n\n  /** Materialize generated data and validate its KPI aggregates. */\n  materializeData(\n    request: MaterializeGeneratorDataRequest,\n    signal?: AbortSignal,\n  ): Promise<MaterializedGeneratorData> {\n    return materializeGeneratorData(\n      request.location,\n      request.plan,\n      this.requiredWarehouseId(),\n      signal,\n    );\n  }\n\n  /** Create and publish a dashboard with automatic companion Genie. */\n  createDashboard(\n    request: CreateGeneratorPresentationRequest,\n    signal?: AbortSignal,\n  ): Promise<GeneratedDashboard> {\n    return createGeneratorDashboard(\n      {\n        location: request.location,\n        plan: request.plan,\n        brand: request.brand.brand,\n        company: request.request.company,\n        purpose: request.request.purpose,\n        warehouseId: this.requiredWarehouseId(),\n      },\n      signal,\n    );\n  }\n\n  /** Create a standalone Genie space for no-dashboard runs. */\n  createGenie(\n    request: CreateGeneratorPresentationRequest,\n    signal?: AbortSignal,\n  ): Promise<GeneratedGenieSpace> {\n    return createGeneratorGenieSpace(\n      {\n        location: request.location,\n        plan: request.plan,\n        company: request.request.company,\n        purpose: request.request.purpose,\n        warehouseId: this.requiredWarehouseId(),\n      },\n      signal,\n    );\n  }\n\n  /** Configured catalog or a deployment-time configuration error. */\n  private requiredCatalog(): string {\n    if (!this.config.catalog) {\n      throw new ConfigurationError(\"GENERATOR_CATALOG is required for generator mutations\");\n    }\n    return this.config.catalog;\n  }\n\n  /** Configured SQL warehouse or a deployment-time configuration error. */\n  private requiredWarehouseId(): string {\n    if (!this.config.warehouseId) {\n      throw new ConfigurationError(\"DATABRICKS_WAREHOUSE_ID is required for generator mutations\");\n    }\n    return this.config.warehouseId;\n  }\n}\n"]}

package/lib/src/palette.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Accessibility normalization for model-generated interface palettes.
+ *
+ * @module
+ */
+import type { GeneratedBrandProfile } from "./schema.ts";
+/** WCAG contrast ratio between two schema-valid hex colors. */
+export declare function colorContrastRatio(foreground: string, background: string): number;
+/** Make generated text and action colors readable against the page background. */
+export declare function normalizeBrandPalette(profile: GeneratedBrandProfile): GeneratedBrandProfile;

package/lib/src/palette.js

@@ -0,0 +1,69 @@
+/**
+ * Accessibility normalization for model-generated interface palettes.
+ *
+ * @module
+ */
+/** Expand a schema-validated hex color into RGB channels. */
+function hexToRgb(color) {
+    const hex = color.slice(1);
+    const expanded = hex.length === 3 ? [...hex].map((value) => `${value}${value}`).join("") : hex.slice(0, 6);
+    return {
+        red: Number.parseInt(expanded.slice(0, 2), 16),
+        green: Number.parseInt(expanded.slice(2, 4), 16),
+        blue: Number.parseInt(expanded.slice(4, 6), 16),
+    };
+}
+/** Serialize RGB channels as a six-digit uppercase hex color. */
+function rgbToHex(color) {
+    const channel = (value) => Math.round(value).toString(16).padStart(2, "0").toUpperCase();
+    return `#${channel(color.red)}${channel(color.green)}${channel(color.blue)}`;
+}
+/** WCAG relative luminance for one sRGB color. */
+function relativeLuminance(color) {
+    const channel = (value) => {
+        const normalized = value / 255;
+        return normalized <= 0.04045 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;
+    };
+    return 0.2126 * channel(color.red) + 0.7152 * channel(color.green) + 0.0722 * channel(color.blue);
+}
+/** WCAG contrast ratio between two schema-valid hex colors. */
+export function colorContrastRatio(foreground, background) {
+    const first = relativeLuminance(hexToRgb(foreground));
+    const second = relativeLuminance(hexToRgb(background));
+    const lighter = Math.max(first, second);
+    const darker = Math.min(first, second);
+    return (lighter + 0.05) / (darker + 0.05);
+}
+/** Blend a color toward black or white past the AA threshold with rendering margin. */
+function ensureContrast(color, background, minimum = 5) {
+    if (colorContrastRatio(color, background) >= minimum)
+        return color;
+    const source = hexToRgb(color);
+    const backgroundIsLight = relativeLuminance(hexToRgb(background)) > 0.5;
+    const target = backgroundIsLight ? 0 : 255;
+    for (let amount = 0.05; amount <= 1; amount += 0.05) {
+        const candidate = rgbToHex({
+            red: source.red + (target - source.red) * amount,
+            green: source.green + (target - source.green) * amount,
+            blue: source.blue + (target - source.blue) * amount,
+        });
+        if (colorContrastRatio(candidate, background) >= minimum)
+            return candidate;
+    }
+    return backgroundIsLight ? "#000000" : "#FFFFFF";
+}
+/** Make generated text and action colors readable against the page background. */
+export function normalizeBrandPalette(profile) {
+    const background = profile.colors.background;
+    return {
+        ...profile,
+        colors: {
+            ...profile.colors,
+            primary: ensureContrast(profile.colors.primary, background),
+            primaryHover: ensureContrast(profile.colors.primaryHover, background),
+            foreground: ensureContrast(profile.colors.foreground, background),
+            muted: ensureContrast(profile.colors.muted, background),
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"palette.js","sourceRoot":"","sources":["../../src/palette.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Accessibility normalization for model-generated interface palettes.\n *\n * @module\n */\n\nimport type { GeneratedBrandProfile } from \"./schema.ts\";\n\ninterface Rgb {\n  red: number;\n  green: number;\n  blue: number;\n}\n\n/** Expand a schema-validated hex color into RGB channels. */\nfunction hexToRgb(color: string): Rgb {\n  const hex = color.slice(1);\n  const expanded =\n    hex.length === 3 ? [...hex].map((value) => `${value}${value}`).join(\"\") : hex.slice(0, 6);\n  return {\n    red: Number.parseInt(expanded.slice(0, 2), 16),\n    green: Number.parseInt(expanded.slice(2, 4), 16),\n    blue: Number.parseInt(expanded.slice(4, 6), 16),\n  };\n}\n\n/** Serialize RGB channels as a six-digit uppercase hex color. */\nfunction rgbToHex(color: Rgb): string {\n  const channel = (value: number) => Math.round(value).toString(16).padStart(2, \"0\").toUpperCase();\n  return `#${channel(color.red)}${channel(color.green)}${channel(color.blue)}`;\n}\n\n/** WCAG relative luminance for one sRGB color. */\nfunction relativeLuminance(color: Rgb): number {\n  const channel = (value: number) => {\n    const normalized = value / 255;\n    return normalized <= 0.04045 ? normalized / 12.92 : ((normalized + 0.055) / 1.055) ** 2.4;\n  };\n  return 0.2126 * channel(color.red) + 0.7152 * channel(color.green) + 0.0722 * channel(color.blue);\n}\n\n/** WCAG contrast ratio between two schema-valid hex colors. */\nexport function colorContrastRatio(foreground: string, background: string): number {\n  const first = relativeLuminance(hexToRgb(foreground));\n  const second = relativeLuminance(hexToRgb(background));\n  const lighter = Math.max(first, second);\n  const darker = Math.min(first, second);\n  return (lighter + 0.05) / (darker + 0.05);\n}\n\n/** Blend a color toward black or white past the AA threshold with rendering margin. */\nfunction ensureContrast(color: string, background: string, minimum = 5): string {\n  if (colorContrastRatio(color, background) >= minimum) return color;\n  const source = hexToRgb(color);\n  const backgroundIsLight = relativeLuminance(hexToRgb(background)) > 0.5;\n  const target = backgroundIsLight ? 0 : 255;\n  for (let amount = 0.05; amount <= 1; amount += 0.05) {\n    const candidate = rgbToHex({\n      red: source.red + (target - source.red) * amount,\n      green: source.green + (target - source.green) * amount,\n      blue: source.blue + (target - source.blue) * amount,\n    });\n    if (colorContrastRatio(candidate, background) >= minimum) return candidate;\n  }\n  return backgroundIsLight ? \"#000000\" : \"#FFFFFF\";\n}\n\n/** Make generated text and action colors readable against the page background. */\nexport function normalizeBrandPalette(profile: GeneratedBrandProfile): GeneratedBrandProfile {\n  const background = profile.colors.background;\n  return {\n    ...profile,\n    colors: {\n      ...profile.colors,\n      primary: ensureContrast(profile.colors.primary, background),\n      primaryHover: ensureContrast(profile.colors.primaryHover, background),\n      foreground: ensureContrast(profile.colors.foreground, background),\n      muted: ensureContrast(profile.colors.muted, background),\n    },\n  };\n}\n"]}

package/lib/src/plan.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Structured demo-data planning from brand and KPI research.
+ *
+ * @module
+ */
+import type { BrandPackage } from "@dbx-tools/shared-generator/brand";
+import type { KpiResearchResult } from "@dbx-tools/shared-generator/kpi";
+import { type GeneratorPlan, type GeneratorRequest } from "@dbx-tools/shared-generator/workflow";
+/** Inputs for deterministic demo-data planning. */
+export interface PlanGeneratorDataInput {
+    /** Validated workflow request. */
+    request: GeneratorRequest;
+    /** Researched brand package. */
+    brand: BrandPackage;
+    /** Evidence-backed KPI research. */
+    kpiResearch: KpiResearchResult;
+    /** Optional model preference. */
+    model?: string;
+}
+/** Build a constrained plan that can be compiled without model-authored SQL. */
+export declare function planGeneratorData(input: PlanGeneratorDataInput, signal?: AbortSignal): Promise<GeneratorPlan>;

package/lib/src/plan.js

@@ -0,0 +1,33 @@
+/**
+ * Structured demo-data planning from brand and KPI research.
+ *
+ * @module
+ */
+import { GeneratorPlanSchema, } from "@dbx-tools/shared-generator/workflow";
+import { generateStructured } from "./structured.js";
+/** Build a constrained plan that can be compiled without model-authored SQL. */
+export async function planGeneratorData(input, signal) {
+    const generated = await generateStructured({
+        id: "demo-data-planner",
+        instructions: [
+            "Plan one denormalized Delta fact table for a realistic business demo.",
+            "Use only the supplied generator kinds and KPI aggregations.",
+            "Include an id column, a date column, two to six useful categories,",
+            "numeric columns needed by every KPI, and a measurable anomaly.",
+            "Do not write SQL. Do not invent unsupported generator fields.",
+        ].join(" "),
+        prompt: JSON.stringify({
+            request: input.request,
+            brand: input.brand.brand,
+            kpis: input.kpiResearch.kpis,
+        }, null, 2),
+        schema: GeneratorPlanSchema,
+        ...(input.model ? { model: input.model } : {}),
+        ...(signal ? { signal } : {}),
+    });
+    return GeneratorPlanSchema.parse({
+        ...generated,
+        rowCount: input.request.rowCount,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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