clivly 0.9.0 → 0.9.1

package/mappings-config-xsLMn3I-.d.cts

@@ -1,167 +0,0 @@
-import { A as ZodRecord, D as ZodLiteral, E as ZodEnum, M as ZodUnion, N as output, O as ZodObject, P as $strict, T as ZodArray, a as ClivlyEntitiesConfig, j as ZodString, k as ZodOptional } from "./entity-config-C4Yf_fPj.cjs";
-//#region ../core/src/projection.d.ts
-/**
- * Projection-backed custom mappings — one custom object derived from a base
- * table plus explicit joins.
- *
- * A projection is deliberately narrow: equality joins only, direct column
- * bindings only, no expressions and no aggregation. Everything a user can
- * express here compiles to a single read-only view whose `id` column is
- * provably unique per row, which is what lets the sync engine consume it
- * unchanged.
- *
- * Refs address tables symbolically: `"base"` for the base table, or a join's
- * `key`. Raw table names are never accepted in a ref, so a projection can
- * never reach a table it did not declare.
- */
-/** The reserved ref name for the projection's base table. */
-declare const BASE_REF = "base";
-declare const projectionRefSchema: ZodObject<{
-  table: ZodString;
-  column: ZodString;
-}, $strict>;
-type ProjectionRef = output<typeof projectionRefSchema>;
-declare const projectionJoinSchema: ZodObject<{
-  key: ZodString;
-  table: ZodString;
-  type: ZodEnum<{
-    inner: "inner";
-    left: "left";
-  }>;
-  on: ZodArray<ZodObject<{
-    left: ZodObject<{
-      table: ZodString;
-      column: ZodString;
-    }, $strict>;
-    op: ZodLiteral<"eq">;
-    right: ZodObject<{
-      table: ZodString;
-      column: ZodString;
-    }, $strict>;
-  }, $strict>>;
-}, $strict>;
-type ProjectionJoin = output<typeof projectionJoinSchema>;
-declare const projectionFieldBindingSchema: ZodObject<{
-  from: ZodObject<{
-    table: ZodString;
-    column: ZodString;
-  }, $strict>;
-}, $strict>;
-type ProjectionFieldBinding = output<typeof projectionFieldBindingSchema>;
-declare const projectionIdentitySchema: ZodUnion<readonly [ZodObject<{
-  kind: ZodLiteral<"base_pk">;
-  column: ZodOptional<ZodString>;
-}, $strict>, ZodObject<{
-  kind: ZodLiteral<"column">;
-  from: ZodObject<{
-    table: ZodString;
-    column: ZodString;
-  }, $strict>;
-}, $strict>, ZodObject<{
-  kind: ZodLiteral<"composite">;
-  parts: ZodArray<ZodObject<{
-    table: ZodString;
-    column: ZodString;
-  }, $strict>>;
-}, $strict>]>;
-type ProjectionIdentity = output<typeof projectionIdentitySchema>;
-declare const projectionSchema: ZodObject<{
-  version: ZodLiteral<1>;
-  kind: ZodLiteral<"projection">;
-  entityKey: ZodString;
-  baseTable: ZodString;
-  joins: ZodArray<ZodObject<{
-    key: ZodString;
-    table: ZodString;
-    type: ZodEnum<{
-      inner: "inner";
-      left: "left";
-    }>;
-    on: ZodArray<ZodObject<{
-      left: ZodObject<{
-        table: ZodString;
-        column: ZodString;
-      }, $strict>;
-      op: ZodLiteral<"eq">;
-      right: ZodObject<{
-        table: ZodString;
-        column: ZodString;
-      }, $strict>;
-    }, $strict>>;
-  }, $strict>>;
-  fieldBindings: ZodRecord<ZodString, ZodObject<{
-    from: ZodObject<{
-      table: ZodString;
-      column: ZodString;
-    }, $strict>;
-  }, $strict>>;
-  identity: ZodUnion<readonly [ZodObject<{
-    kind: ZodLiteral<"base_pk">;
-    column: ZodOptional<ZodString>;
-  }, $strict>, ZodObject<{
-    kind: ZodLiteral<"column">;
-    from: ZodObject<{
-      table: ZodString;
-      column: ZodString;
-    }, $strict>;
-  }, $strict>, ZodObject<{
-    kind: ZodLiteral<"composite">;
-    parts: ZodArray<ZodObject<{
-      table: ZodString;
-      column: ZodString;
-    }, $strict>>;
-  }, $strict>]>;
-}, $strict>;
-type ProjectionMapping = output<typeof projectionSchema>;
-/**
- * Every column ref an identity depends on. `basePkColumn` is the base table's
- * discovered PK, used only when a `base_pk` identity omits an explicit column.
- */
-declare function identityRefs(identity: ProjectionIdentity, basePkColumn: string): ProjectionRef[];
-//#endregion
-//#region ../core/src/mappings-config.d.ts
-/**
- * Mappings → Entity Config bridge.
- *
- * `crm_entity_mappings` rows are the single source of truth for how a host
- * schema maps onto Clivly's CRM concepts. This module compiles those rows into
- * a `ClivlyEntitiesConfig` — the contract the view compiler and sync engine
- * consume — so the persisted mapping and the runtime pipeline never diverge.
- *
- * The row model has no explicit entity-key column (it's keyed by
- * `sourceTable + targetConcept + role`), but the config's `relationships`
- * reference other entities *by key*. This builder therefore derives a stable
- * key per row and resolves each relationship's `entity` reference through the
- * same derivation — so a relationship stored as `entity: "<relatedTable>"`
- * (the shape `mappings.suggest` produces) resolves to the right entity.
- */
-/**
- * A persisted `crm_entity_mappings` row, narrowed to the columns the builder
- * reads. Structurally compatible with the Drizzle row (jsonb columns typed
- * loosely) so the API layer can pass `db.select()` results straight in.
- */
-interface EntityMappingRow {
-  fieldMap: Record<string, string>;
-  filter?: Record<string, unknown> | null;
-  /**
-   * Advanced mapping: a base table plus explicit joins. When set, this — not
-   * `fieldMap` — is the authored source of truth, and `sourceTable` merely
-   * mirrors `projection.baseTable`.
-   */
-  projection?: ProjectionMapping | null;
-  relationships?: Record<string, unknown> | null;
-  role?: string | null;
-  sourceTable: string;
-  status?: string | null;
-  targetConcept: string;
-  targetObjectTypeId?: string | null;
-}
-/**
- * Compile persisted mapping rows into a `ClivlyEntitiesConfig`. Only `active`
- * rows with at least one mapped field are included; disabled/suggested rows and
- * unmapped rows are skipped. Returns `{ entities: {} }` when nothing is
- * eligible — a no-op the view compiler and sync engine both tolerate.
- */
-declare function mappingsToEntitiesConfig(rows: EntityMappingRow[]): ClivlyEntitiesConfig;
-//#endregion
-export { ProjectionIdentity as a, ProjectionRef as c, ProjectionFieldBinding as i, identityRefs as l, mappingsToEntitiesConfig as n, ProjectionJoin as o, BASE_REF as r, ProjectionMapping as s, EntityMappingRow as t, projectionSchema as u };