@kaelio/ktx 0.4.0 → 0.5.0

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/mapping.js

@@ -1,220 +0,0 @@
-export const METABASE_ENGINE_TO_CONNECTION_TYPE = {
-    postgres: 'POSTGRESQL',
-    bigquery: 'BIGQUERY',
-    'bigquery-cloud-sdk': 'BIGQUERY',
-    snowflake: 'SNOWFLAKE',
-    sqlserver: 'SQLSERVER',
-    mysql: 'MYSQL',
-};
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-function readString(record, key) {
-    const value = record[key];
-    return typeof value === 'string' && value.length > 0 ? value : null;
-}
-function normalizeHost(host) {
-    if (typeof host !== 'string' || host.length === 0) {
-        return null;
-    }
-    return host.toLowerCase().replace(/:\d+$/, '');
-}
-function normalizeName(name) {
-    if (typeof name !== 'string' || name.length === 0) {
-        return null;
-    }
-    return name.toLowerCase();
-}
-function displayValue(value) {
-    return typeof value === 'string' && value.length > 0 ? value : 'unknown';
-}
-function getTargetDatabase(target) {
-    if (target.connection_type === 'BIGQUERY') {
-        return target.dataset_id ?? target.project_id ?? target.database;
-    }
-    return target.database;
-}
-function extractHost(params, connectionType) {
-    switch (connectionType) {
-        case 'POSTGRESQL':
-        case 'SQLSERVER':
-        case 'MYSQL':
-            return readString(params, 'host');
-        case 'SNOWFLAKE':
-            return readString(params, 'account');
-        default:
-            return null;
-    }
-}
-function extractDatabase(params, connectionType) {
-    switch (connectionType) {
-        case 'POSTGRESQL':
-        case 'SQLSERVER':
-        case 'SNOWFLAKE':
-        case 'MYSQL':
-            return readString(params, 'database');
-        case 'BIGQUERY':
-            return readString(params, 'dataset_id');
-        default:
-            return null;
-    }
-}
-function toDiscoveredMetabaseDatabase(database) {
-    const details = isRecord(database.details) ? database.details : {};
-    return {
-        id: database.id,
-        name: database.name,
-        engine: database.engine ?? '',
-        host: readString(details, 'host'),
-        dbName: readString(details, 'dbname') ?? readString(details, 'db'),
-    };
-}
-export async function discoverMetabaseDatabases(client) {
-    const databases = await client.getDatabases();
-    return databases.filter((database) => !database.is_sample).map(toDiscoveredMetabaseDatabase);
-}
-export function computeMetabaseMappingDrift(args) {
-    const discoveredById = new Map(args.discovered.map((database) => [String(database.id), database]));
-    const unmappedDiscovered = args.discovered.filter((database) => !args.currentMappings[String(database.id)]);
-    const staleMappings = Object.keys(args.currentMappings)
-        .filter((id) => !discoveredById.has(id))
-        .map((id) => ({ id, reason: 'database_not_found' }));
-    const inSync = Object.entries(args.currentMappings)
-        .filter(([id, ktxConnectionId]) => discoveredById.has(id) && typeof ktxConnectionId === 'string')
-        .map(([id, ktxConnectionId]) => ({ id: Number(id), ktxConnectionId: ktxConnectionId }));
-    return { unmappedDiscovered, staleMappings, inSync };
-}
-export function validateMetabaseMappings(args) {
-    const errors = [];
-    for (const [key, connectionId] of Object.entries(args.mappings)) {
-        if (!connectionId) {
-            continue;
-        }
-        if (!args.knownKtxConnectionIds.has(connectionId)) {
-            errors.push({ key, reason: `KTX connection ${connectionId} does not exist` });
-        }
-    }
-    return errors.length === 0 ? { ok: true } : { ok: false, errors };
-}
-export function validateMappingPhysicalMatch(mapping, target) {
-    const engine = mapping.metabaseEngine?.toLowerCase();
-    if (!engine) {
-        return null;
-    }
-    const expectedType = METABASE_ENGINE_TO_CONNECTION_TYPE[engine];
-    if (!expectedType) {
-        return null;
-    }
-    if (target.connection_type !== expectedType) {
-        return `Metabase database engine '${engine}' does not match KTX connection type '${target.connection_type}'`;
-    }
-    const metabaseDb = normalizeName(mapping.metabaseDbName);
-    const targetDb = normalizeName(getTargetDatabase(target));
-    if (engine === 'snowflake' || engine === 'bigquery' || engine === 'bigquery-cloud-sdk') {
-        if (metabaseDb && targetDb && metabaseDb !== targetDb) {
-            return `Metabase database '${mapping.metabaseDbName}' does not match KTX connection database '${displayValue(getTargetDatabase(target))}'`;
-        }
-        return null;
-    }
-    if (engine === 'postgres' || engine === 'mysql' || engine === 'sqlserver') {
-        const metabaseHost = normalizeHost(mapping.metabaseHost);
-        const targetHost = normalizeHost(target.host);
-        if (metabaseHost && targetHost && metabaseHost !== targetHost) {
-            return `Metabase host '${mapping.metabaseHost}' does not match KTX connection host '${displayValue(target.host)}'`;
-        }
-        if (metabaseDb && targetDb && metabaseDb !== targetDb) {
-            return `Metabase database '${mapping.metabaseDbName}' does not match KTX connection database '${displayValue(getTargetDatabase(target))}'`;
-        }
-        return null;
-    }
-    return null;
-}
-export function computeMetabaseMappingPhysicalMismatches(inputs) {
-    const mismatches = [];
-    for (const input of inputs) {
-        const reason = validateMappingPhysicalMatch(input.metabase, input.target);
-        if (reason) {
-            mismatches.push({ mappingId: input.mappingId, reason });
-        }
-    }
-    return mismatches;
-}
-export async function refreshMetabaseMapping(args) {
-    const discovered = await discoverMetabaseDatabases(args.client);
-    const drift = computeMetabaseMappingDrift({ currentMappings: args.currentMappings, discovered });
-    const discoveredById = new Map(discovered.map((database) => [database.id, database]));
-    const physicalMismatches = [];
-    for (const mapping of drift.inSync) {
-        const discoveredDatabase = discoveredById.get(mapping.id);
-        if (!discoveredDatabase) {
-            continue;
-        }
-        const target = await args.resolveKtxConnectionPhysicalInfo(mapping.ktxConnectionId);
-        if (!target) {
-            physicalMismatches.push({
-                mappingId: String(mapping.id),
-                reason: `KTX connection ${mapping.ktxConnectionId} does not exist`,
-            });
-            continue;
-        }
-        const reason = validateMappingPhysicalMatch({
-            metabaseEngine: discoveredDatabase.engine,
-            metabaseHost: discoveredDatabase.host,
-            metabaseDbName: discoveredDatabase.dbName,
-        }, target);
-        if (reason) {
-            physicalMismatches.push({ mappingId: String(mapping.id), reason });
-        }
-    }
-    return { drift, physicalMismatches };
-}
-export function findBestMatch(mapping, candidates) {
-    const engine = mapping.metabaseEngine?.toLowerCase();
-    if (!engine) {
-        return null;
-    }
-    const expectedType = METABASE_ENGINE_TO_CONNECTION_TYPE[engine];
-    if (!expectedType) {
-        return null;
-    }
-    const compatibleConnections = candidates.filter((candidate) => candidate.connection_type === expectedType);
-    if (compatibleConnections.length === 0) {
-        return null;
-    }
-    const metabaseHost = normalizeHost(mapping.metabaseHost);
-    const metabaseDb = normalizeName(mapping.metabaseDbName);
-    let bestMatch = null;
-    let bestScore = 0;
-    for (const connection of compatibleConnections) {
-        if (!isRecord(connection.connection_params)) {
-            continue;
-        }
-        const connHost = normalizeHost(extractHost(connection.connection_params, connection.connection_type));
-        const connDb = normalizeName(extractDatabase(connection.connection_params, connection.connection_type));
-        const hostMatch = metabaseHost && connHost && metabaseHost === connHost;
-        const dbMatch = metabaseDb && connDb && metabaseDb === connDb;
-        let score = 0;
-        let reason = 'host_only';
-        if (hostMatch && dbMatch) {
-            score = 3;
-            reason = 'host_and_database';
-        }
-        else if (dbMatch) {
-            score = 2;
-            reason = 'database_only';
-        }
-        else if (hostMatch) {
-            score = 1;
-            reason = 'host_only';
-        }
-        if (score > bestScore) {
-            bestScore = score;
-            bestMatch = {
-                connectionId: connection.id,
-                connectionName: connection.name,
-                reason,
-            };
-        }
-    }
-    return bestMatch;
-}

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/serialize-card.d.ts

@@ -1,53 +0,0 @@
-import type { StagedCardFile } from './types.js';
-/**
- * Input TemplateTag shape mirrors `MetabaseClient.getTemplateTags` output. We keep the
- * shape loose — only `name`, `type`, and optional `cardReference`/`default` are needed here.
- */
-export interface InputTemplateTag {
-    name: string;
-    type: string;
-    cardReference?: number | null;
-    defaultValue?: string | null;
-}
-export declare function extractReferencedCardIds(templateTags: InputTemplateTag[], sql: string): number[];
-/**
- * Input card shape — matches the fields `MetabaseClient.getCard()` returns that we
- * care about. The adapter reads whatever the client returns; this helper stays
- * duck-typed so the client's type can evolve without churn here.
- */
-export interface InputCard {
-    id: number;
-    name: string;
-    description?: string | null;
-    type: string;
-    database_id: number;
-    collection_id?: number | 'root' | null;
-    archived?: boolean;
-    result_metadata?: Array<{
-        name: string;
-        display_name?: string | null;
-        base_type: string;
-        semantic_type?: string | null;
-        description?: string | null;
-        fk_target_field_id?: number | null;
-        field_ref?: unknown[] | null;
-    }> | null;
-    parameters?: Array<{
-        id: string;
-        name: string;
-        type: string;
-        slug?: string | null;
-        default?: unknown;
-        sectionId?: string | null;
-    }> | null;
-    last_run_at?: string | null;
-    dashboard_count?: number | null;
-}
-export interface SerializeCardParams {
-    card: InputCard;
-    resolvedSql: string;
-    templateTags: InputTemplateTag[];
-    collectionPath: string[];
-    resolutionStatus: 'resolved' | 'fallback';
-}
-export declare function serializeCard(params: SerializeCardParams): StagedCardFile;

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/serialize-card.js

@@ -1,67 +0,0 @@
-const CARD_REF_RE = /\{\{#(\d+)\}\}/g;
-export function extractReferencedCardIds(templateTags, sql) {
-    const ids = new Set();
-    for (const tag of templateTags) {
-        if (tag.type === 'card' && typeof tag.cardReference === 'number') {
-            ids.add(tag.cardReference);
-        }
-    }
-    for (const match of sql.matchAll(CARD_REF_RE)) {
-        const n = Number.parseInt(match[1], 10);
-        if (Number.isFinite(n) && n > 0) {
-            ids.add(n);
-        }
-    }
-    return [...ids].sort((a, b) => a - b);
-}
-function toStagedColumn(col) {
-    return {
-        name: col.name,
-        display_name: col.display_name ?? null,
-        base_type: col.base_type,
-        semantic_type: col.semantic_type ?? null,
-        description: col.description ?? null,
-        fk_target_field_id: col.fk_target_field_id ?? null,
-        field_ref: col.field_ref ?? null,
-    };
-}
-function toStagedParameter(param) {
-    return {
-        id: param.id,
-        name: param.name,
-        type: param.type,
-        slug: param.slug ?? null,
-        default: param.default ?? null,
-        sectionId: param.sectionId ?? null,
-    };
-}
-function toStagedTemplateTag(tag) {
-    return {
-        name: tag.name,
-        type: tag.type,
-        defaultValue: tag.defaultValue ?? null,
-        cardReference: tag.cardReference ?? null,
-    };
-}
-export function serializeCard(params) {
-    const { card, resolvedSql, templateTags, collectionPath, resolutionStatus } = params;
-    const referencedCardIds = extractReferencedCardIds(templateTags, resolvedSql);
-    return {
-        metabaseId: card.id,
-        name: card.name,
-        description: card.description ?? null,
-        type: card.type,
-        databaseId: card.database_id,
-        collectionId: card.collection_id ?? null,
-        archived: card.archived ?? false,
-        resolvedSql,
-        templateTags: templateTags.map(toStagedTemplateTag),
-        resultMetadata: (card.result_metadata ?? []).map(toStagedColumn),
-        collectionPath,
-        referencedCardIds,
-        parameters: (card.parameters ?? []).map(toStagedParameter),
-        lastRunAt: card.last_run_at ?? null,
-        dashboardCount: card.dashboard_count ?? null,
-        resolutionStatus,
-    };
-}

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/source-state-port.d.ts

@@ -1,23 +0,0 @@
-import type { MetabaseSyncMode } from './types.js';
-export interface MetabaseSourceStateSelection {
-    selectionType: 'collection' | 'item';
-    metabaseObjectId: number;
-}
-export interface MetabaseSourceStateMapping {
-    metabaseDatabaseId: number;
-    metabaseDatabaseName: string | null;
-    metabaseEngine: string | null;
-    metabaseHost?: string | null;
-    metabaseDbName?: string | null;
-    targetConnectionId: string | null;
-    syncEnabled: boolean;
-}
-export interface MetabaseSourceState {
-    syncMode: MetabaseSyncMode;
-    selections: MetabaseSourceStateSelection[];
-    defaultTagNames: string[];
-    mappings: MetabaseSourceStateMapping[];
-}
-export interface MetabaseSourceStateReader {
-    getSourceState(connectionId: string): Promise<MetabaseSourceState>;
-}

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/types.d.ts

@@ -1,142 +0,0 @@
-import { z } from 'zod';
-export declare const metabaseSyncModeSchema: z.ZodEnum<{
-    ALL: "ALL";
-    ONLY: "ONLY";
-    EXCEPT: "EXCEPT";
-}>;
-export type MetabaseSyncMode = z.infer<typeof metabaseSyncModeSchema>;
-export declare const metabaseLocalConnectionIdSchema: z.ZodString;
-/**
- * The lean config the adapter needs at `fetch()` time. Lives in the BullMQ payload's
- * `bundleRef.config` when the runner invokes the adapter. Never persisted beyond one
- * job — the persisted state (enabled/disabled, auth, scheduling) lives on the
- * Metabase connection's `connections.config` JSONB.
- */
-export declare const metabasePullConfigSchema: z.ZodObject<{
-    metabaseConnectionId: z.ZodString;
-    metabaseDatabaseId: z.ZodNumber;
-}, z.core.$strip>;
-export type MetabasePullConfig = z.infer<typeof metabasePullConfigSchema>;
-export declare function parseMetabasePullConfig(raw: unknown): MetabasePullConfig;
-/** A Metabase column from `card.result_metadata`. Mirrors what the LLM consumes today. */
-export declare const stagedResultColumnSchema: z.ZodObject<{
-    name: z.ZodString;
-    display_name: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    base_type: z.ZodString;
-    semantic_type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    fk_target_field_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-    field_ref: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
-}, z.core.$strip>;
-export type StagedResultColumn = z.infer<typeof stagedResultColumnSchema>;
-export declare const stagedParameterSchema: z.ZodObject<{
-    id: z.ZodString;
-    name: z.ZodString;
-    type: z.ZodString;
-    slug: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    default: z.ZodNullable<z.ZodOptional<z.ZodUnknown>>;
-    sectionId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-}, z.core.$strip>;
-export type StagedParameter = z.infer<typeof stagedParameterSchema>;
-/** A template tag pulled from an MBQL card's `dataset_query.stages[0].template-tags`. */
-export declare const stagedTemplateTagSchema: z.ZodObject<{
-    name: z.ZodString;
-    type: z.ZodString;
-    defaultValue: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    cardReference: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-}, z.core.$strip>;
-export type StagedTemplateTag = z.infer<typeof stagedTemplateTagSchema>;
-/**
- * A serialized card file, one per `cards/<id>.json`. Hashed content-addressably by
- * the runner — key inputs that change cause re-ingest, cosmetic fields do not.
- */
-export declare const stagedCardFileSchema: z.ZodObject<{
-    metabaseId: z.ZodNumber;
-    name: z.ZodString;
-    description: z.ZodNullable<z.ZodString>;
-    type: z.ZodString;
-    databaseId: z.ZodNumber;
-    collectionId: z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"root">]>>;
-    archived: z.ZodBoolean;
-    resolvedSql: z.ZodString;
-    templateTags: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        type: z.ZodString;
-        defaultValue: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        cardReference: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-    }, z.core.$strip>>;
-    resultMetadata: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        display_name: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        base_type: z.ZodString;
-        semantic_type: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        description: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        fk_target_field_id: z.ZodNullable<z.ZodOptional<z.ZodNumber>>;
-        field_ref: z.ZodNullable<z.ZodOptional<z.ZodArray<z.ZodUnknown>>>;
-    }, z.core.$strip>>;
-    collectionPath: z.ZodArray<z.ZodString>;
-    referencedCardIds: z.ZodArray<z.ZodNumber>;
-    parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        type: z.ZodString;
-        slug: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-        default: z.ZodNullable<z.ZodOptional<z.ZodUnknown>>;
-        sectionId: z.ZodNullable<z.ZodOptional<z.ZodString>>;
-    }, z.core.$strip>>>;
-    lastRunAt: z.ZodDefault<z.ZodNullable<z.ZodString>>;
-    dashboardCount: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
-    resolutionStatus: z.ZodEnum<{
-        resolved: "resolved";
-        fallback: "fallback";
-    }>;
-}, z.core.$strip>;
-export type StagedCardFile = z.infer<typeof stagedCardFileSchema>;
-/** A serialized collection file, `collections/<id>.json`. Minimal — path lives on the card. */
-export declare const stagedCollectionFileSchema: z.ZodObject<{
-    metabaseId: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"root">]>;
-    name: z.ZodString;
-    parentId: z.ZodNullable<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"root">]>>;
-}, z.core.$strip>;
-export type StagedCollectionFile = z.infer<typeof stagedCollectionFileSchema>;
-/** A serialized database-mapping snapshot, `databases/<id>.json`. */
-export declare const stagedDatabaseFileSchema: z.ZodObject<{
-    metabaseDatabaseId: z.ZodNumber;
-    metabaseDatabaseName: z.ZodString;
-    metabaseEngine: z.ZodNullable<z.ZodString>;
-    targetConnectionId: z.ZodString;
-}, z.core.$strip>;
-export type StagedDatabaseFile = z.infer<typeof stagedDatabaseFileSchema>;
-/** The filter snapshot. Written once per `fetch()` to `sync-config.json`. */
-export declare const stagedSyncConfigSchema: z.ZodObject<{
-    metabaseConnectionId: z.ZodString;
-    metabaseDatabaseId: z.ZodNumber;
-    syncMode: z.ZodEnum<{
-        ALL: "ALL";
-        ONLY: "ONLY";
-        EXCEPT: "EXCEPT";
-    }>;
-    selections: z.ZodArray<z.ZodObject<{
-        selectionType: z.ZodEnum<{
-            item: "item";
-            collection: "collection";
-        }>;
-        metabaseObjectId: z.ZodNumber;
-    }, z.core.$strip>>;
-    defaultTagNames: z.ZodArray<z.ZodString>;
-    mapping: z.ZodObject<{
-        metabaseDatabaseId: z.ZodNumber;
-        metabaseDatabaseName: z.ZodString;
-        metabaseEngine: z.ZodNullable<z.ZodString>;
-        targetConnectionId: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type StagedSyncConfig = z.infer<typeof stagedSyncConfigSchema>;
-/** Filenames inside stagedDir. Centralized so chunk() + fetch() + detect() all agree. */
-export declare const STAGED_FILES: {
-    readonly syncConfig: "sync-config.json";
-    readonly cardsDir: "cards";
-    readonly collectionsDir: "collections";
-    readonly databasesDir: "databases";
-    readonly unresolvedCards: "unresolved-cards.json";
-};

package/node_modules/@ktx/context/dist/ingest/adapters/metabase/types.js

@@ -1,106 +0,0 @@
-import { z } from 'zod';
-export const metabaseSyncModeSchema = z.enum(['ALL', 'ONLY', 'EXCEPT']);
-export const metabaseLocalConnectionIdSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/);
-/**
- * The lean config the adapter needs at `fetch()` time. Lives in the BullMQ payload's
- * `bundleRef.config` when the runner invokes the adapter. Never persisted beyond one
- * job — the persisted state (enabled/disabled, auth, scheduling) lives on the
- * Metabase connection's `connections.config` JSONB.
- */
-export const metabasePullConfigSchema = z.object({
-    /** The Metabase connection (source) — the thing being swept. */
-    metabaseConnectionId: metabaseLocalConnectionIdSchema,
-    /** The Metabase-side database id whose cards this bundle pulls (one bundle = one database). */
-    metabaseDatabaseId: z.number().int().positive(),
-});
-export function parseMetabasePullConfig(raw) {
-    return metabasePullConfigSchema.parse(raw);
-}
-/** A Metabase column from `card.result_metadata`. Mirrors what the LLM consumes today. */
-export const stagedResultColumnSchema = z.object({
-    name: z.string(),
-    display_name: z.string().optional().nullable(),
-    base_type: z.string(),
-    semantic_type: z.string().optional().nullable(),
-    description: z.string().optional().nullable(),
-    fk_target_field_id: z.number().optional().nullable(),
-    field_ref: z.array(z.unknown()).optional().nullable(),
-});
-export const stagedParameterSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    type: z.string(),
-    slug: z.string().optional().nullable(),
-    default: z.unknown().optional().nullable(),
-    sectionId: z.string().optional().nullable(),
-});
-/** A template tag pulled from an MBQL card's `dataset_query.stages[0].template-tags`. */
-export const stagedTemplateTagSchema = z.object({
-    name: z.string(),
-    type: z.string(),
-    defaultValue: z.string().optional().nullable(),
-    /** If this tag is a saved-question reference (`{{#42}}`), the referenced card id. Null for plain tags. */
-    cardReference: z.number().int().positive().optional().nullable(),
-});
-/**
- * A serialized card file, one per `cards/<id>.json`. Hashed content-addressably by
- * the runner — key inputs that change cause re-ingest, cosmetic fields do not.
- */
-export const stagedCardFileSchema = z.object({
-    metabaseId: z.number().int().positive(),
-    name: z.string(),
-    description: z.string().nullable(),
-    type: z.string(), // 'question' | 'model' | 'metric'
-    databaseId: z.number().int().positive(),
-    collectionId: z.union([z.number().int(), z.literal('root')]).nullable(),
-    archived: z.boolean(),
-    resolvedSql: z.string(),
-    templateTags: z.array(stagedTemplateTagSchema),
-    resultMetadata: z.array(stagedResultColumnSchema),
-    /** Full collection breadcrumb path, e.g. ['Data', 'Orders Team']. `[]` for root cards. */
-    collectionPath: z.array(z.string()),
-    /** Card ids this card references via `{{#N}}` template tags or other saved-question refs. */
-    referencedCardIds: z.array(z.number().int().positive()),
-    parameters: z.array(stagedParameterSchema).default([]),
-    lastRunAt: z.string().nullable().default(null),
-    dashboardCount: z.number().int().nullable().default(null),
-    resolutionStatus: z.enum(['resolved', 'fallback']),
-});
-/** A serialized collection file, `collections/<id>.json`. Minimal — path lives on the card. */
-export const stagedCollectionFileSchema = z.object({
-    metabaseId: z.union([z.number().int(), z.literal('root')]),
-    name: z.string(),
-    parentId: z.union([z.number().int(), z.literal('root')]).nullable(),
-});
-/** A serialized database-mapping snapshot, `databases/<id>.json`. */
-export const stagedDatabaseFileSchema = z.object({
-    metabaseDatabaseId: z.number().int().positive(),
-    metabaseDatabaseName: z.string(),
-    metabaseEngine: z.string().nullable(),
-    targetConnectionId: metabaseLocalConnectionIdSchema,
-});
-/** The filter snapshot. Written once per `fetch()` to `sync-config.json`. */
-export const stagedSyncConfigSchema = z.object({
-    metabaseConnectionId: metabaseLocalConnectionIdSchema,
-    metabaseDatabaseId: z.number().int().positive(),
-    syncMode: metabaseSyncModeSchema,
-    selections: z.array(z.object({
-        selectionType: z.enum(['collection', 'item']),
-        metabaseObjectId: z.number().int(),
-    })),
-    defaultTagNames: z.array(z.string()),
-    mapping: z.object({
-        metabaseDatabaseId: z.number().int().positive(),
-        metabaseDatabaseName: z.string(),
-        metabaseEngine: z.string().nullable(),
-        targetConnectionId: metabaseLocalConnectionIdSchema,
-    }),
-});
-/** Filenames inside stagedDir. Centralized so chunk() + fetch() + detect() all agree. */
-export const STAGED_FILES = {
-    syncConfig: 'sync-config.json',
-    cardsDir: 'cards',
-    collectionsDir: 'collections',
-    databasesDir: 'databases',
-    unresolvedCards: 'unresolved-cards.json',
-};

package/node_modules/@ktx/context/dist/ingest/adapters/metricflow/deep-parse.d.ts

@@ -1,77 +0,0 @@
-import { type KtxLogger } from '../../../core/index.js';
-export interface DimensionDefinition {
-    name: string;
-    column: string;
-    type: string;
-    label?: string;
-    description?: string;
-}
-export interface SimpleMeasureDefinition {
-    type: 'simple';
-    name: string;
-    column: string;
-    aggregation: 'sum' | 'count' | 'count_distinct' | 'avg' | 'min' | 'max' | 'median' | 'none';
-    label?: string;
-    description?: string;
-    filter?: string;
-    cumulative?: boolean;
-}
-export type MeasureDefinition = SimpleMeasureDefinition | {
-    type: 'derived';
-    name: string;
-    expr: string;
-    dependsOn?: string[];
-    label?: string;
-    description?: string;
-};
-export interface ParsedMetricflowRelationship {
-    fromTable: string;
-    fromColumn: string;
-    toTable: string;
-    toColumn: string;
-    fromSchema?: string;
-    toSchema?: string;
-    description?: string;
-}
-export interface MetricflowParseOptions {
-    logger?: KtxLogger;
-}
-interface MetricFlowEntity {
-    name: string;
-    type: 'primary' | 'foreign' | 'unique' | 'natural';
-    expr?: string;
-    description?: string;
-}
-export interface ParsedSemanticModel {
-    name: string;
-    description: string | null;
-    modelRef: string;
-    dimensions: DimensionDefinition[];
-    measures: MeasureDefinition[];
-    entities: MetricFlowEntity[];
-    defaultTimeDimension: string | null;
-}
-export interface ParsedCrossModelMetric {
-    name: string;
-    label: string | null;
-    description: string | null;
-    type: 'derived';
-    expr: string;
-    dependsOn: Array<{
-        metricName: string;
-        alias?: string;
-    }>;
-    filter: string | null;
-}
-export interface MetricFlowParseResult {
-    semanticModels: ParsedSemanticModel[];
-    crossModelMetrics: ParsedCrossModelMetric[];
-    relationships: ParsedMetricflowRelationship[];
-    warnings: string[];
-}
-export declare function parseMetricflowFiles(files: Array<{
-    content: string;
-    path: string;
-}>, options?: MetricflowParseOptions): MetricFlowParseResult;
-export declare function translateMetricflowJinjaFilter(filter: string): string;
-export {};