clivly 0.8.0 → 0.9.0

package/vite.d.mts

@@ -1,4 +1,4 @@
-import { t as ClivlySDK } from "./types-CsL0rFYh.mjs";
+import { o as ClivlySDK } from "./namespace-probe-Dsp5uNkS.mjs";
 import { Plugin } from "vite";
 //#region ../sdk/src/vite.d.ts
 interface ClivlyViteOptions {

package/drizzle-B89tLo4T.mjs

@@ -1,31 +0,0 @@
-import { Table, getTableColumns, getTableName, is } from "drizzle-orm";
-//#region ../core/src/drizzle.ts
-/**
-* Derive Clivly's discovery shape (table + column names) from a Drizzle schema
-* object — the `* as schema` you pass to `drizzle(client, { schema })`. This
-* delivers the "reads your schema" promise for Drizzle hosts: no hand-authored
-* `DiscoveredTable[]`. Feed the result to the SDK's `schema` option, or diff it
-* against your entity config.
-*
-* Column names are the real database column names (e.g. `full_name`), not the
-* Drizzle property keys (`fullName`). Non-table values in the schema object
-* (relations, enums, helpers) are ignored.
-*
-* `drizzle-orm` is an **optional peer dependency** — you only need it installed
-* when you import this entry (`@clivly/core/drizzle`); the rest of `@clivly/core`
-* stays dependency-free.
-*/
-function discoverFromDrizzle(schema) {
-	const tables = [];
-	for (const value of Object.values(schema)) {
-		if (!is(value, Table)) continue;
-		const columns = getTableColumns(value);
-		tables.push({
-			name: getTableName(value),
-			columns: Object.values(columns).map((column) => column.name)
-		});
-	}
-	return tables;
-}
-//#endregion
-export { discoverFromDrizzle as t };

package/drizzle-CFOr9dU9.d.mts

@@ -1,20 +0,0 @@
-import { u as DiscoveredSchemaTable } from "./entity-config-DoUCXtq5.mjs";
-//#region ../core/src/drizzle.d.ts
-/**
- * Derive Clivly's discovery shape (table + column names) from a Drizzle schema
- * object — the `* as schema` you pass to `drizzle(client, { schema })`. This
- * delivers the "reads your schema" promise for Drizzle hosts: no hand-authored
- * `DiscoveredTable[]`. Feed the result to the SDK's `schema` option, or diff it
- * against your entity config.
- *
- * Column names are the real database column names (e.g. `full_name`), not the
- * Drizzle property keys (`fullName`). Non-table values in the schema object
- * (relations, enums, helpers) are ignored.
- *
- * `drizzle-orm` is an **optional peer dependency** — you only need it installed
- * when you import this entry (`@clivly/core/drizzle`); the rest of `@clivly/core`
- * stays dependency-free.
- */
-declare function discoverFromDrizzle(schema: Record<string, unknown>): DiscoveredSchemaTable[];
-//#endregion
-export { discoverFromDrizzle as t };

package/drizzle-DiReZf6d.cjs

@@ -1,36 +0,0 @@
-let drizzle_orm = require("drizzle-orm");
-//#region ../core/src/drizzle.ts
-/**
-* Derive Clivly's discovery shape (table + column names) from a Drizzle schema
-* object — the `* as schema` you pass to `drizzle(client, { schema })`. This
-* delivers the "reads your schema" promise for Drizzle hosts: no hand-authored
-* `DiscoveredTable[]`. Feed the result to the SDK's `schema` option, or diff it
-* against your entity config.
-*
-* Column names are the real database column names (e.g. `full_name`), not the
-* Drizzle property keys (`fullName`). Non-table values in the schema object
-* (relations, enums, helpers) are ignored.
-*
-* `drizzle-orm` is an **optional peer dependency** — you only need it installed
-* when you import this entry (`@clivly/core/drizzle`); the rest of `@clivly/core`
-* stays dependency-free.
-*/
-function discoverFromDrizzle(schema) {
-	const tables = [];
-	for (const value of Object.values(schema)) {
-		if (!(0, drizzle_orm.is)(value, drizzle_orm.Table)) continue;
-		const columns = (0, drizzle_orm.getTableColumns)(value);
-		tables.push({
-			name: (0, drizzle_orm.getTableName)(value),
-			columns: Object.values(columns).map((column) => column.name)
-		});
-	}
-	return tables;
-}
-//#endregion
-Object.defineProperty(exports, "discoverFromDrizzle", {
-	enumerable: true,
-	get: function() {
-		return discoverFromDrizzle;
-	}
-});

package/drizzle-DmeKSqeF.d.cts

@@ -1,20 +0,0 @@
-import { u as DiscoveredSchemaTable } from "./entity-config-DoUCXtq5.cjs";
-//#region ../core/src/drizzle.d.ts
-/**
- * Derive Clivly's discovery shape (table + column names) from a Drizzle schema
- * object — the `* as schema` you pass to `drizzle(client, { schema })`. This
- * delivers the "reads your schema" promise for Drizzle hosts: no hand-authored
- * `DiscoveredTable[]`. Feed the result to the SDK's `schema` option, or diff it
- * against your entity config.
- *
- * Column names are the real database column names (e.g. `full_name`), not the
- * Drizzle property keys (`fullName`). Non-table values in the schema object
- * (relations, enums, helpers) are ignored.
- *
- * `drizzle-orm` is an **optional peer dependency** — you only need it installed
- * when you import this entry (`@clivly/core/drizzle`); the rest of `@clivly/core`
- * stays dependency-free.
- */
-declare function discoverFromDrizzle(schema: Record<string, unknown>): DiscoveredSchemaTable[];
-//#endregion
-export { discoverFromDrizzle as t };

package/mappings-config-DsUa7-1w.d.mts

@@ -1,41 +0,0 @@
-import { a as ClivlyEntitiesConfig } from "./entity-config-DoUCXtq5.mjs";
-//#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;
-  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 { mappingsToEntitiesConfig as n, EntityMappingRow as t };

package/mappings-config-XmzB4dag.d.cts

@@ -1,41 +0,0 @@
-import { a as ClivlyEntitiesConfig } from "./entity-config-DoUCXtq5.cjs";
-//#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;
-  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 { mappingsToEntitiesConfig as n, EntityMappingRow as t };

package/types-CsL0rFYh.d.cts

@@ -1,155 +0,0 @@
-//#region ../sdk/src/drizzle-meta.d.ts
-declare const DRIZZLE_META: "__clivly_drizzle_source_meta__";
-interface DrizzleSourceMeta {
-  /** Drizzle property keys of every column on the source table. */
-  columnKeys: string[];
-  /** Schema-v2 typed column metadata derived from the Drizzle table. */
-  columnsMeta?: DiscoveredColumn[];
-  cursorField: string;
-  idField: string;
-  /** The backing table's real name, so discovery can key metadata by table. */
-  tableName?: string;
-}
-//#endregion
-//#region ../sdk/src/types.d.ts
-interface DiscoveredColumn {
-  isForeignKey?: boolean;
-  isPrimaryKey?: boolean;
-  name: string;
-  nullable?: boolean;
-  /** The column this FK points at, when it is a foreign key. */
-  references?: {
-    table: string;
-    column: string;
-  };
-  /** SQL/driver type, e.g. "text", "integer", "timestamp". */
-  type?: string;
-}
-interface ClivlyUser {
-  email: string;
-  id: string;
-  name?: string;
-}
-interface DoctorCheck {
-  /** Human-readable outcome — what passed, or why it failed. */
-  detail: string;
-  /** Short label, e.g. "API key present". */
-  name: string;
-  /** True when the check passed. Ignored when `skipped` is true. */
-  ok: boolean;
-  /** True when the check could not run (e.g. a hand-written source). */
-  skipped?: boolean;
-}
-interface DoctorReport {
-  checks: DoctorCheck[];
-  /** AND of every non-skipped check's `ok`. */
-  ok: boolean;
-}
-type ClivlyConnectReason = "ok" | "invalid_api_key" | "forbidden" | "rate_limited" | "server_error" | "client_error" | "network_error";
-interface ClivlyConnectResult {
-  ok: boolean;
-  /** Org resolved from a successful heartbeat, when the server returns it. */
-  org?: {
-    id?: string;
-    name?: string;
-  };
-  reason: ClivlyConnectReason;
-  /** Whether a retry could plausibly succeed (network, 429, 5xx). */
-  retryable: boolean;
-  /** HTTP status, or null when the request never completed (network error). */
-  status: number | null;
-}
-interface SyncCursor {
-  /** The row's id, breaking ties when timestamps collide. */
-  id: string;
-  /** The row's cursor-field value (typically `updated_at`). */
-  time: Date;
-}
-interface SyncSource {
-  cursorField: string;
-  entity: string;
-  fetchPage(args: {
-    since: SyncCursor | null;
-    limit: number;
-  }): Promise<Record<string, unknown>[]>;
-  /** Stable, unique tie-breaker column for keyset paging. Defaults to "id". */
-  idField?: string;
-  /** Set by `fromDrizzle`; lets `doctor` introspect the backing table. */
-  [DRIZZLE_META]?: DrizzleSourceMeta;
-}
-type SyncMode = "delta" | "full";
-interface ClivlySDK {
-  /**
-   * Send a single heartbeat and report the outcome richly: `ok`, the HTTP
-   * `status` (null on network failure), a coarse `reason`, whether it's
-   * `retryable`, and the resolved `org` when the server returns it. Never throws
-   * — inspect the result, or turn a failure into an exception with
-   * `ClivlyError.from(result)`. Prefer this over `heartbeat()` for onboarding,
-   * health checks, and one-shot serverless calls.
-   */
-  connect(): Promise<ClivlyConnectResult>;
-  /**
-   * Build the `/clivly/auth/verify` handler the developer mounts in their app.
-   * Clivly's cloud calls it to validate a CRM user's identity against the host
-   * app's session. Pass a resolver that reads the host session from the request.
-   *
-   * The handler authenticates the caller against `config.verifyToken` (presented
-   * as `Authorization: Bearer <token>`) before invoking the resolver, so the
-   * endpoint can't be used by third parties to probe host sessions. It fails
-   * closed with HTTP 503 if `verifyToken` is unset (a missing config value, not a
-   * server fault — so it won't trip the host's 5xx error alerting).
-   */
-  createAuthVerifyHandler(resolveUser: (req: Request) => Promise<ClivlyUser | null> | ClivlyUser | null): (req: Request) => Promise<Response>;
-  /**
-   * A fetch handler to mount at a route. Each request runs one `runScheduled()`
-   * and returns JSON: 200 when the sync succeeded, 500 otherwise.
-   *
-   * Two callers use it: Clivly Cloud (when someone clicks "Run sync" — those
-   * requests are HMAC-signed and carry a run id), and the host's own scheduler
-   * (Workers cron, an uptime ping — no body).
-   *
-   * When `syncTrigger.secret` is set the handler rejects unsigned or
-   * badly-signed requests with 401. When it isn't, the route stays open to
-   * anyone who can reach it — set a secret if it's publicly routable.
-   */
-  createClivlyHandler(): (req: Request) => Promise<Response>;
-  /** Validate this setup end-to-end (read-only) before the first sync. */
-  doctor(): Promise<DoctorReport>;
-  /**
-   * Send a single heartbeat now. Returns true on success. Kept for the keep-alive
-   * loop and back-compat; use `connect()` when you need the failure reason.
-   */
-  heartbeat(): Promise<boolean>;
-  /**
-   * One-shot heartbeat + a single sync, with no keep-alive timers. The correct
-   * entry point on serverless/edge (Workers, Vercel, Lambda), where `start()`'s
-   * `setInterval` loop can't persist between invocations — call this from a
-   * scheduled/cron trigger. Throws if a sync push fails (so the run is marked
-   * failed); heartbeat is best-effort.
-   */
-  runScheduled(options?: {
-    mode?: SyncMode;
-    runId?: string;
-  }): Promise<void>;
-  /**
-   * Send the initial heartbeat and start the keep-alive loop. For long-lived
-   * hosts only — on serverless/edge the interval can't persist, so prefer
-   * `runScheduled()` / `createClivlyHandler()`. Emits a warning if a serverless
-   * runtime is detected.
-   */
-  start(): Promise<void>;
-  /** Stop the keep-alive loop. */
-  stop(): void;
-  /**
-   * Sync all configured sources now. `delta` (default) pages changed rows since
-   * the last cursor; `full` pushes each complete entity so the server can
-   * reconcile leavers (archive-on-leave). Throws if a push fails, so callers see
-   * the failure — the background keep-alive loop swallows and retries instead.
-   */
-  sync(options?: {
-    mode?: SyncMode;
-    runId?: string;
-  }): Promise<void>;
-}
-//#endregion
-export { SyncSource as n, ClivlySDK as t };

package/types-CsL0rFYh.d.mts

@@ -1,155 +0,0 @@
-//#region ../sdk/src/drizzle-meta.d.ts
-declare const DRIZZLE_META: "__clivly_drizzle_source_meta__";
-interface DrizzleSourceMeta {
-  /** Drizzle property keys of every column on the source table. */
-  columnKeys: string[];
-  /** Schema-v2 typed column metadata derived from the Drizzle table. */
-  columnsMeta?: DiscoveredColumn[];
-  cursorField: string;
-  idField: string;
-  /** The backing table's real name, so discovery can key metadata by table. */
-  tableName?: string;
-}
-//#endregion
-//#region ../sdk/src/types.d.ts
-interface DiscoveredColumn {
-  isForeignKey?: boolean;
-  isPrimaryKey?: boolean;
-  name: string;
-  nullable?: boolean;
-  /** The column this FK points at, when it is a foreign key. */
-  references?: {
-    table: string;
-    column: string;
-  };
-  /** SQL/driver type, e.g. "text", "integer", "timestamp". */
-  type?: string;
-}
-interface ClivlyUser {
-  email: string;
-  id: string;
-  name?: string;
-}
-interface DoctorCheck {
-  /** Human-readable outcome — what passed, or why it failed. */
-  detail: string;
-  /** Short label, e.g. "API key present". */
-  name: string;
-  /** True when the check passed. Ignored when `skipped` is true. */
-  ok: boolean;
-  /** True when the check could not run (e.g. a hand-written source). */
-  skipped?: boolean;
-}
-interface DoctorReport {
-  checks: DoctorCheck[];
-  /** AND of every non-skipped check's `ok`. */
-  ok: boolean;
-}
-type ClivlyConnectReason = "ok" | "invalid_api_key" | "forbidden" | "rate_limited" | "server_error" | "client_error" | "network_error";
-interface ClivlyConnectResult {
-  ok: boolean;
-  /** Org resolved from a successful heartbeat, when the server returns it. */
-  org?: {
-    id?: string;
-    name?: string;
-  };
-  reason: ClivlyConnectReason;
-  /** Whether a retry could plausibly succeed (network, 429, 5xx). */
-  retryable: boolean;
-  /** HTTP status, or null when the request never completed (network error). */
-  status: number | null;
-}
-interface SyncCursor {
-  /** The row's id, breaking ties when timestamps collide. */
-  id: string;
-  /** The row's cursor-field value (typically `updated_at`). */
-  time: Date;
-}
-interface SyncSource {
-  cursorField: string;
-  entity: string;
-  fetchPage(args: {
-    since: SyncCursor | null;
-    limit: number;
-  }): Promise<Record<string, unknown>[]>;
-  /** Stable, unique tie-breaker column for keyset paging. Defaults to "id". */
-  idField?: string;
-  /** Set by `fromDrizzle`; lets `doctor` introspect the backing table. */
-  [DRIZZLE_META]?: DrizzleSourceMeta;
-}
-type SyncMode = "delta" | "full";
-interface ClivlySDK {
-  /**
-   * Send a single heartbeat and report the outcome richly: `ok`, the HTTP
-   * `status` (null on network failure), a coarse `reason`, whether it's
-   * `retryable`, and the resolved `org` when the server returns it. Never throws
-   * — inspect the result, or turn a failure into an exception with
-   * `ClivlyError.from(result)`. Prefer this over `heartbeat()` for onboarding,
-   * health checks, and one-shot serverless calls.
-   */
-  connect(): Promise<ClivlyConnectResult>;
-  /**
-   * Build the `/clivly/auth/verify` handler the developer mounts in their app.
-   * Clivly's cloud calls it to validate a CRM user's identity against the host
-   * app's session. Pass a resolver that reads the host session from the request.
-   *
-   * The handler authenticates the caller against `config.verifyToken` (presented
-   * as `Authorization: Bearer <token>`) before invoking the resolver, so the
-   * endpoint can't be used by third parties to probe host sessions. It fails
-   * closed with HTTP 503 if `verifyToken` is unset (a missing config value, not a
-   * server fault — so it won't trip the host's 5xx error alerting).
-   */
-  createAuthVerifyHandler(resolveUser: (req: Request) => Promise<ClivlyUser | null> | ClivlyUser | null): (req: Request) => Promise<Response>;
-  /**
-   * A fetch handler to mount at a route. Each request runs one `runScheduled()`
-   * and returns JSON: 200 when the sync succeeded, 500 otherwise.
-   *
-   * Two callers use it: Clivly Cloud (when someone clicks "Run sync" — those
-   * requests are HMAC-signed and carry a run id), and the host's own scheduler
-   * (Workers cron, an uptime ping — no body).
-   *
-   * When `syncTrigger.secret` is set the handler rejects unsigned or
-   * badly-signed requests with 401. When it isn't, the route stays open to
-   * anyone who can reach it — set a secret if it's publicly routable.
-   */
-  createClivlyHandler(): (req: Request) => Promise<Response>;
-  /** Validate this setup end-to-end (read-only) before the first sync. */
-  doctor(): Promise<DoctorReport>;
-  /**
-   * Send a single heartbeat now. Returns true on success. Kept for the keep-alive
-   * loop and back-compat; use `connect()` when you need the failure reason.
-   */
-  heartbeat(): Promise<boolean>;
-  /**
-   * One-shot heartbeat + a single sync, with no keep-alive timers. The correct
-   * entry point on serverless/edge (Workers, Vercel, Lambda), where `start()`'s
-   * `setInterval` loop can't persist between invocations — call this from a
-   * scheduled/cron trigger. Throws if a sync push fails (so the run is marked
-   * failed); heartbeat is best-effort.
-   */
-  runScheduled(options?: {
-    mode?: SyncMode;
-    runId?: string;
-  }): Promise<void>;
-  /**
-   * Send the initial heartbeat and start the keep-alive loop. For long-lived
-   * hosts only — on serverless/edge the interval can't persist, so prefer
-   * `runScheduled()` / `createClivlyHandler()`. Emits a warning if a serverless
-   * runtime is detected.
-   */
-  start(): Promise<void>;
-  /** Stop the keep-alive loop. */
-  stop(): void;
-  /**
-   * Sync all configured sources now. `delta` (default) pages changed rows since
-   * the last cursor; `full` pushes each complete entity so the server can
-   * reconcile leavers (archive-on-leave). Throws if a push fails, so callers see
-   * the failure — the background keep-alive loop swallows and retries instead.
-   */
-  sync(options?: {
-    mode?: SyncMode;
-    runId?: string;
-  }): Promise<void>;
-}
-//#endregion
-export { SyncSource as n, ClivlySDK as t };