hazo_collect 0.2.1

package/dist/run-envelope-COvdsleR.d.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+
+declare const ManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<["source", "sink"]>;
+    version: z.ZodString;
+    runtime: z.ZodEnum<["node", "python"]>;
+    entry: z.ZodString;
+    schedule: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodDefault<z.ZodString>;
+    timeout_sec: z.ZodDefault<z.ZodNumber>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    retry: z.ZodOptional<z.ZodObject<{
+        max: z.ZodDefault<z.ZodNumber>;
+        backoff: z.ZodDefault<z.ZodEnum<["exponential", "linear", "constant"]>>;
+        base_ms: z.ZodDefault<z.ZodNumber>;
+        jitter: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        max: number;
+        backoff: "exponential" | "linear" | "constant";
+        base_ms: number;
+        jitter: boolean;
+    }, {
+        max?: number | undefined;
+        backoff?: "exponential" | "linear" | "constant" | undefined;
+        base_ms?: number | undefined;
+        jitter?: boolean | undefined;
+    }>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    produces: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    consumes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    idempotency_key: z.ZodArray<z.ZodString, "many">;
+    labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    kind: "source" | "sink";
+    version: string;
+    runtime: "node" | "python";
+    entry: string;
+    timezone: string;
+    timeout_sec: number;
+    concurrency: number;
+    idempotency_key: string[];
+    schedule?: string | undefined;
+    retry?: {
+        max: number;
+        backoff: "exponential" | "linear" | "constant";
+        base_ms: number;
+        jitter: boolean;
+    } | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    produces?: string[] | undefined;
+    consumes?: string[] | undefined;
+    secrets?: string[] | undefined;
+    labels?: Record<string, string> | undefined;
+}, {
+    name: string;
+    kind: "source" | "sink";
+    version: string;
+    runtime: "node" | "python";
+    entry: string;
+    idempotency_key: string[];
+    schedule?: string | undefined;
+    timezone?: string | undefined;
+    timeout_sec?: number | undefined;
+    concurrency?: number | undefined;
+    retry?: {
+        max?: number | undefined;
+        backoff?: "exponential" | "linear" | "constant" | undefined;
+        base_ms?: number | undefined;
+        jitter?: boolean | undefined;
+    } | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    produces?: string[] | undefined;
+    consumes?: string[] | undefined;
+    secrets?: string[] | undefined;
+    labels?: Record<string, string> | undefined;
+}>;
+type Manifest = z.infer<typeof ManifestSchema>;
+declare function parseManifest(input: unknown): Manifest;
+
+declare const RunEnvelopeSchema: z.ZodObject<{
+    run_id: z.ZodString;
+    correlation_id: z.ZodString;
+    plugin: z.ZodString;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    secrets: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    window: z.ZodOptional<z.ZodObject<{
+        since: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        since?: string | undefined;
+        until?: string | undefined;
+    }, {
+        since?: string | undefined;
+        until?: string | undefined;
+    }>>;
+    attempt: z.ZodDefault<z.ZodNumber>;
+    contract_version: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    inputs: Record<string, unknown>;
+    secrets: Record<string, string>;
+    plugin: string;
+    run_id: string;
+    contract_version: string;
+    correlation_id: string;
+    attempt: number;
+    window?: {
+        since?: string | undefined;
+        until?: string | undefined;
+    } | undefined;
+}, {
+    plugin: string;
+    run_id: string;
+    correlation_id: string;
+    inputs?: Record<string, unknown> | undefined;
+    secrets?: Record<string, string> | undefined;
+    contract_version?: string | undefined;
+    window?: {
+        since?: string | undefined;
+        until?: string | undefined;
+    } | undefined;
+    attempt?: number | undefined;
+}>;
+type RunEnvelope = z.infer<typeof RunEnvelopeSchema>;
+declare function parseRunEnvelope(input: unknown): RunEnvelope;
+
+export { type Manifest as M, type RunEnvelope as R, ManifestSchema as a, RunEnvelopeSchema as b, parseRunEnvelope as c, parseManifest as p };

package/dist/run-result-qW7bJEZ-.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+
+declare const RunErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    context: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    retryable?: boolean | undefined;
+    context?: unknown;
+}, {
+    code: string;
+    message: string;
+    retryable?: boolean | undefined;
+    context?: unknown;
+}>;
+declare const RunResultSchema: z.ZodObject<{
+    plugin: z.ZodString;
+    run_id: z.ZodString;
+    kind: z.ZodEnum<["source", "sink"]>;
+    started_at: z.ZodString;
+    completed_at: z.ZodString;
+    status: z.ZodEnum<["success", "partial", "failed"]>;
+    records_fetched: z.ZodNumber;
+    records_written: z.ZodNumber;
+    watermark: z.ZodOptional<z.ZodString>;
+    errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        context: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        context?: unknown;
+    }, {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        context?: unknown;
+    }>, "many">>;
+    metrics: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    contract_version: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "success" | "partial" | "failed";
+    kind: "source" | "sink";
+    plugin: string;
+    run_id: string;
+    started_at: string;
+    completed_at: string;
+    records_fetched: number;
+    records_written: number;
+    errors: {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        context?: unknown;
+    }[];
+    contract_version: string;
+    watermark?: string | undefined;
+    metrics?: Record<string, number> | undefined;
+}, {
+    status: "success" | "partial" | "failed";
+    kind: "source" | "sink";
+    plugin: string;
+    run_id: string;
+    started_at: string;
+    completed_at: string;
+    records_fetched: number;
+    records_written: number;
+    watermark?: string | undefined;
+    errors?: {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        context?: unknown;
+    }[] | undefined;
+    metrics?: Record<string, number> | undefined;
+    contract_version?: string | undefined;
+}>;
+type RunResult = z.infer<typeof RunResultSchema>;
+type RunError = z.infer<typeof RunErrorSchema>;
+declare function parseRunResult(input: unknown): RunResult;
+
+export { type RunError as R, type RunResult as a, RunResultSchema as b, parseRunResult as p };

package/dist/sdk/index.d.ts

@@ -0,0 +1,5 @@
+import 'hazo_core';
+import '../run-envelope-COvdsleR.js';
+export { a as CollectorContext, b as CollectorDefinition, c as CollectorOutcome, S as SinkDefinition, g as defineCollector, h as defineSink, i as getCollector, j as getSink, l as listCollectors, r as resetCollectorRegistry } from '../index-C47n5Xur.js';
+import 'zod';
+import 'hazo_connect/server';

package/dist/sdk/index.js

@@ -0,0 +1,47 @@
+// src/sdk/index.ts
+import { HazoConfigError } from "hazo_core";
+var _collectors = /* @__PURE__ */ new Map();
+var _sinks = /* @__PURE__ */ new Map();
+function defineCollector(def) {
+  if (_collectors.has(def.manifest.name)) {
+    throw new HazoConfigError({
+      code: "HAZO_COLLECT_DUPLICATE_COLLECTOR",
+      pkg: "hazo_collect",
+      message: `Collector "${def.manifest.name}" is already registered`
+    });
+  }
+  _collectors.set(def.manifest.name, def);
+  return def;
+}
+function getCollector(name) {
+  return _collectors.get(name);
+}
+function listCollectors() {
+  return Array.from(_collectors.values());
+}
+function defineSink(def) {
+  if (_sinks.has(def.manifest.name)) {
+    throw new HazoConfigError({
+      code: "HAZO_COLLECT_DUPLICATE_SINK",
+      pkg: "hazo_collect",
+      message: `Sink "${def.manifest.name}" is already registered`
+    });
+  }
+  _sinks.set(def.manifest.name, def);
+  return def;
+}
+function getSink(name) {
+  return _sinks.get(name);
+}
+function resetCollectorRegistry() {
+  _collectors.clear();
+  _sinks.clear();
+}
+export {
+  defineCollector,
+  defineSink,
+  getCollector,
+  getSink,
+  listCollectors,
+  resetCollectorRegistry
+};

package/dist/server/index.d.ts

@@ -0,0 +1,66 @@
+import { b as CollectorDefinition, c as CollectorOutcome } from '../index-C47n5Xur.js';
+export { C as CanonicalTarget, L as LandingRow, W as WriteAdapter, d as WriteArgs, e as WriteResult, f as createWriteAdapter } from '../index-C47n5Xur.js';
+import { HazoConnectAdapter, DbResult } from 'hazo_connect/server';
+import { a as RunResult } from '../run-result-qW7bJEZ-.js';
+import { M as Manifest, R as RunEnvelope } from '../run-envelope-COvdsleR.js';
+import 'hazo_core';
+import 'zod';
+
+interface DiscoverOptions {
+    adapter: HazoConnectAdapter;
+    pluginsDir?: string;
+    reseed?: boolean;
+}
+declare function discover(opts: DiscoverOptions): Promise<Registry>;
+
+interface RegistryEntry {
+    manifest: Manifest;
+    worker: CollectorDefinition;
+}
+interface Registry {
+    get(name: string): RegistryEntry | undefined;
+    list(): RegistryEntry[];
+    refresh?(): Promise<void>;
+}
+declare function createInMemoryRegistry(): Registry;
+/**
+ * Upsert all registry entries into hazo_collect_plugin_registry.
+ * Invalid manifests (parse failure) are quarantined: valid=0, quarantine_reason=error message.
+ */
+declare function persistRegistry(adapter: HazoConnectAdapter, entries: Array<{
+    manifest: Manifest;
+    source?: string;
+}>, opts?: {
+    reseed?: boolean;
+}): Promise<DbResult<void>>;
+
+interface RuntimeAdapter {
+    run(def: CollectorDefinition, envelope: RunEnvelope, adapter: HazoConnectAdapter): Promise<{
+        ok: true;
+        outcome: CollectorOutcome;
+    } | {
+        ok: false;
+        error: unknown;
+    }>;
+}
+declare const nodeRuntime: RuntimeAdapter;
+
+interface SecretsProvider {
+    resolve(names: string[]): Promise<Record<string, string>>;
+    get(name: string): Promise<string>;
+}
+interface ManagerOptions {
+    adapter: HazoConnectAdapter;
+    registry: Registry;
+    secrets?: SecretsProvider;
+    runtime?: RuntimeAdapter;
+}
+interface Manager {
+    runNow(pluginName: string, opts?: {
+        inputs?: unknown;
+    }): Promise<DbResult<RunResult>>;
+    runEnvelope(envelope: RunEnvelope): Promise<DbResult<RunResult>>;
+}
+declare function createManager(opts: ManagerOptions): Manager;
+
+export { type DiscoverOptions, type Manager, type ManagerOptions, type Registry, type RegistryEntry, type RuntimeAdapter, createInMemoryRegistry, createManager, discover, nodeRuntime, persistRegistry };