@lde/distribution-monitor 0.1.1

package/README.md

@@ -0,0 +1,180 @@
+# Distribution Monitor
+
+Monitor DCAT distributions (SPARQL endpoints and data dumps) with periodic probes, storing observations in PostgreSQL. Uses [`@lde/distribution-probe`](../distribution-probe) for the actual health check.
+
+## Installation
+
+```bash
+npm install @lde/distribution-monitor
+```
+
+## CLI Usage
+
+The easiest way to run the monitor is via the CLI with a configuration file.
+
+### Quick Start
+
+1. Create a configuration file (TypeScript, JavaScript, JSON, or YAML)
+2. Run the monitor
+
+```bash
+# Start continuous monitoring
+npx distribution-monitor start
+
+# Run a one-off check for all monitors
+npx distribution-monitor check
+
+# Check a specific monitor
+npx distribution-monitor check dbpedia
+
+# Use a custom config path
+npx distribution-monitor start --config ./configs/production.config.ts
+```
+
+### TypeScript Config (`distribution-monitor.config.ts`)
+
+```typescript
+import { defineConfig } from '@lde/distribution-monitor';
+
+export default defineConfig({
+  databaseUrl: process.env.DATABASE_URL,
+  intervalSeconds: 300,
+  timeoutMs: 30_000,
+  monitors: [
+    {
+      identifier: 'dbpedia',
+      distribution: {
+        accessUrl: 'https://dbpedia.org/sparql',
+        conformsTo: 'https://www.w3.org/TR/sparql11-protocol/',
+      },
+      sparqlQuery: 'ASK { ?s ?p ?o }',
+    },
+    {
+      identifier: 'wikidata',
+      distribution: {
+        accessUrl: 'https://query.wikidata.org/sparql',
+        conformsTo: 'https://www.w3.org/TR/sparql11-protocol/',
+      },
+      sparqlQuery: 'SELECT * WHERE { ?s ?p ?o } LIMIT 1',
+    },
+    {
+      identifier: 'my-dump',
+      distribution: {
+        accessUrl: 'https://example.org/data.nt',
+        mediaType: 'application/n-triples',
+      },
+    },
+  ],
+});
+```
+
+### YAML Config (`distribution-monitor.config.yaml`)
+
+```yaml
+databaseUrl: ${DATABASE_URL}
+intervalSeconds: 300
+monitors:
+  - identifier: dbpedia
+    distribution:
+      accessUrl: https://dbpedia.org/sparql
+      conformsTo: https://www.w3.org/TR/sparql11-protocol/
+    sparqlQuery: ASK { ?s ?p ?o }
+  - identifier: my-dump
+    distribution:
+      accessUrl: https://example.org/data.nt
+      mediaType: application/n-triples
+```
+
+### Environment Variables
+
+Create a `.env` file for sensitive configuration:
+
+```
+DATABASE_URL=postgres://user:pass@localhost:5432/monitoring
+```
+
+The CLI automatically loads `.env` files.
+
+### Config Auto-Discovery
+
+The CLI searches for configuration in this order:
+
+1. `distribution-monitor.config.{ts,mts,js,mjs,json,yaml,yml}`
+2. `.distribution-monitorrc`
+3. `package.json` → `"distribution-monitor"` key
+
+## Programmatic Usage
+
+```typescript
+import { Distribution } from '@lde/dataset';
+import {
+  MonitorService,
+  PostgresObservationStore,
+  type MonitorConfig,
+} from '@lde/distribution-monitor';
+
+const monitors: MonitorConfig[] = [
+  {
+    identifier: 'dbpedia',
+    distribution: Distribution.sparql(new URL('https://dbpedia.org/sparql')),
+    sparqlQuery: 'ASK { ?s ?p ?o }',
+  },
+  {
+    identifier: 'my-dump',
+    distribution: new Distribution(
+      new URL('https://example.org/data.nt'),
+      'application/n-triples',
+    ),
+  },
+];
+
+const store = await PostgresObservationStore.create(
+  'postgres://user:pass@localhost:5432/db',
+);
+
+const service = new MonitorService({
+  store,
+  monitors,
+  intervalSeconds: 300,
+  timeoutMs: 30_000,
+  headers: new Headers({ 'User-Agent': 'my-monitor/1.0' }),
+});
+
+service.start();
+// …or run immediate checks
+await service.checkAll();
+await service.checkNow('dbpedia');
+
+const observations = await store.getLatest();
+for (const [identifier, observation] of observations) {
+  console.log(
+    `${identifier}: ${observation.success ? 'OK' : 'FAIL'} (${
+      observation.responseTimeMs
+    }ms)`,
+  );
+}
+
+service.stop();
+await store.close();
+```
+
+## Distribution shape
+
+Each monitor targets a DCAT `Distribution`. Supply:
+
+- `accessUrl` — required. The URL to probe.
+- `mediaType` (optional) — plain content-type (e.g. `application/n-triples`) or DCAT-AP 3.0 IANA URI. Omit for SPARQL endpoints that only serve the protocol.
+- `conformsTo` (optional) — use `https://www.w3.org/TR/sparql11-protocol/` to mark a distribution as a SPARQL endpoint. Required when `accessUrl` doesn’t already imply SPARQL via `mediaType`.
+- `sparqlQuery` (optional) — for SPARQL endpoints. Query type (ASK / SELECT / CONSTRUCT / DESCRIBE) is autodetected. Defaults to a minimal `SELECT` availability probe.
+
+Distributions with embedded credentials (`https://user:pass@host/path`) are supported: the credentials are stripped from the URL and forwarded as an `Authorization: Basic` header.
+
+## Database Initialisation
+
+`PostgresObservationStore.create()` automatically initializes the database schema:
+
+- `observations` table for storing check results
+- `latest_observations` materialized view for efficient queries
+- Required indexes
+
+This is idempotent and safe to call on every startup.

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { loadConfig } from 'c12';
+import { createRequire } from 'node:module';
+import { MonitorService } from './service.js';
+import { PostgresObservationStore } from './store.js';
+import { normalizeConfig } from './config.js';
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+async function loadMonitorContext(configFile) {
+    const { config: rawConfig } = await loadConfig({
+        name: 'distribution-monitor',
+        configFile,
+        dotenv: true,
+    });
+    if (!rawConfig) {
+        console.error('Error: No configuration found.');
+        console.error('Create a distribution-monitor.config.ts file or specify --config.');
+        process.exit(1);
+    }
+    const config = normalizeConfig(rawConfig);
+    const databaseUrl = config.databaseUrl ?? process.env.DATABASE_URL;
+    if (!databaseUrl) {
+        console.error('Error: databaseUrl required (set in config or DATABASE_URL env).');
+        process.exit(1);
+    }
+    if (config.monitors.length === 0) {
+        console.error('Error: No monitors configured.');
+        process.exit(1);
+    }
+    const store = await PostgresObservationStore.create(databaseUrl);
+    const service = new MonitorService({
+        store,
+        monitors: config.monitors,
+        intervalSeconds: config.intervalSeconds,
+        timeoutMs: config.timeoutMs,
+    });
+    return {
+        config: { ...config, databaseUrl },
+        store,
+        service,
+    };
+}
+const program = new Command();
+program
+    .name('distribution-monitor')
+    .description('Monitor DCAT distributions (SPARQL endpoints and data dumps)')
+    .version(version);
+program
+    .command('start')
+    .description('Start monitoring all configured distributions')
+    .option('-c, --config <path>', 'Config file path')
+    .action(async (options) => {
+    const { config, store, service } = await loadMonitorContext(options.config);
+    await service.checkAll();
+    service.start();
+    console.log(`Monitoring ${config.monitors.length} distribution(s)...`);
+    console.log(`Interval: ${config.intervalSeconds ?? 300} seconds`);
+    const shutdown = async () => {
+        console.log('\nShutting down...');
+        service.stop();
+        await store.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+});
+program
+    .command('check [identifier]')
+    .description('Run immediate check (all monitors or specific one)')
+    .option('-c, --config <path>', 'Config file path')
+    .action(async (identifier, options) => {
+    const { config, store, service } = await loadMonitorContext(options.config);
+    try {
+        if (identifier) {
+            const monitor = config.monitors.find((m) => m.identifier === identifier);
+            if (!monitor) {
+                console.error(`Error: Monitor '${identifier}' not found.`);
+                console.error('Available monitors:', config.monitors.map((m) => m.identifier).join(', '));
+                process.exit(1);
+            }
+            console.log(`Checking ${identifier}...`);
+            await service.checkNow(identifier);
+            console.log(`Check completed for ${identifier}.`);
+        }
+        else {
+            console.log(`Checking ${config.monitors.length} distribution(s)...`);
+            await service.checkAll();
+            console.log('All checks completed.');
+        }
+    }
+    finally {
+        await store.close();
+    }
+});
+program.parse();

package/dist/config.d.ts

@@ -0,0 +1,86 @@
+import type { MonitorConfig } from './types.js';
+/**
+ * Shape of a single monitor entry in a configuration file. URLs may be
+ * supplied as strings for YAML/JSON ergonomics; they are converted to
+ * {@link URL} objects by {@link normalizeConfig}.
+ */
+export interface RawMonitorConfig {
+    /** Unique identifier for this monitor. */
+    identifier: string;
+    /** The distribution to probe. */
+    distribution: {
+        /** Distribution access URL. */
+        accessUrl: string | URL;
+        /**
+         * Plain content-type (e.g. `application/n-triples`) or DCAT-AP 3.0
+         * IANA media type URI.
+         */
+        mediaType?: string;
+        /**
+         * Specification the distribution conforms to, e.g.
+         * `https://www.w3.org/TR/sparql11-protocol/` for SPARQL endpoints.
+         */
+        conformsTo?: string | URL;
+    };
+    /**
+     * SPARQL query to run against SPARQL-endpoint distributions. Ignored for
+     * data-dump distributions.
+     */
+    sparqlQuery?: string;
+}
+/**
+ * Configuration for the distribution monitor.
+ */
+export interface DistributionMonitorConfig {
+    /** PostgreSQL connection string. */
+    databaseUrl?: string;
+    /** Polling interval in seconds (default: 300). */
+    intervalSeconds?: number;
+    /** Request timeout in milliseconds (default: 30 000). */
+    timeoutMs?: number;
+    /** Monitor definitions. */
+    monitors: RawMonitorConfig[];
+}
+/**
+ * Type helper for TypeScript config files.
+ *
+ * @example
+ * ```ts
+ * // distribution-monitor.config.ts
+ * import { defineConfig } from '@lde/distribution-monitor';
+ *
+ * export default defineConfig({
+ *   databaseUrl: process.env.DATABASE_URL,
+ *   intervalSeconds: 300,
+ *   monitors: [
+ *     {
+ *       identifier: 'dbpedia',
+ *       distribution: {
+ *         accessUrl: 'https://dbpedia.org/sparql',
+ *         conformsTo: 'https://www.w3.org/TR/sparql11-protocol/',
+ *       },
+ *       sparqlQuery: 'ASK { ?s ?p ?o }',
+ *     },
+ *     {
+ *       identifier: 'my-dump',
+ *       distribution: {
+ *         accessUrl: 'https://example.org/data.nt',
+ *         mediaType: 'application/n-triples',
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export declare function defineConfig(config: DistributionMonitorConfig): DistributionMonitorConfig;
+/**
+ * Normalize config: convert string URLs to URL objects and construct
+ * {@link Distribution} instances for each monitor.
+ */
+export declare function normalizeConfig(raw: DistributionMonitorConfig): {
+    databaseUrl?: string;
+    intervalSeconds?: number;
+    timeoutMs?: number;
+    monitors: MonitorConfig[];
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,iCAAiC;IACjC,YAAY,EAAE;QACZ,+BAA+B;QAC/B,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC;QACxB;;;WAGG;QACH,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB;;;WAGG;QACH,UAAU,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;KAC3B,CAAC;IACF;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2BAA2B;IAC3B,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,yBAAyB,GAChC,yBAAyB,CAE3B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,yBAAyB,GAAG;IAC/D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,aAAa,EAAE,CAAC;CAC3B,CAWA"}

package/dist/config.js

@@ -0,0 +1,60 @@
+import { Distribution } from '@lde/dataset';
+/**
+ * Type helper for TypeScript config files.
+ *
+ * @example
+ * ```ts
+ * // distribution-monitor.config.ts
+ * import { defineConfig } from '@lde/distribution-monitor';
+ *
+ * export default defineConfig({
+ *   databaseUrl: process.env.DATABASE_URL,
+ *   intervalSeconds: 300,
+ *   monitors: [
+ *     {
+ *       identifier: 'dbpedia',
+ *       distribution: {
+ *         accessUrl: 'https://dbpedia.org/sparql',
+ *         conformsTo: 'https://www.w3.org/TR/sparql11-protocol/',
+ *       },
+ *       sparqlQuery: 'ASK { ?s ?p ?o }',
+ *     },
+ *     {
+ *       identifier: 'my-dump',
+ *       distribution: {
+ *         accessUrl: 'https://example.org/data.nt',
+ *         mediaType: 'application/n-triples',
+ *       },
+ *     },
+ *   ],
+ * });
+ * ```
+ */
+export function defineConfig(config) {
+    return config;
+}
+/**
+ * Normalize config: convert string URLs to URL objects and construct
+ * {@link Distribution} instances for each monitor.
+ */
+export function normalizeConfig(raw) {
+    return {
+        databaseUrl: raw.databaseUrl,
+        intervalSeconds: raw.intervalSeconds,
+        timeoutMs: raw.timeoutMs,
+        monitors: raw.monitors.map((m) => ({
+            identifier: m.identifier,
+            distribution: toDistribution(m.distribution),
+            sparqlQuery: m.sparqlQuery,
+        })),
+    };
+}
+function toDistribution(raw) {
+    const accessUrl = typeof raw.accessUrl === 'string' ? new URL(raw.accessUrl) : raw.accessUrl;
+    const conformsTo = raw.conformsTo === undefined
+        ? undefined
+        : typeof raw.conformsTo === 'string'
+            ? new URL(raw.conformsTo)
+            : raw.conformsTo;
+    return new Distribution(accessUrl, raw.mediaType, conformsTo);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { MonitorConfig, CheckResult, Observation, ObservationStore, } from './types.js';
+export { PostgresObservationStore } from './store.js';
+export { MonitorService, mapProbeResult, type MonitorServiceOptions, type Probe, } from './service.js';
+export { defineConfig, normalizeConfig, type DistributionMonitorConfig, type RawMonitorConfig, } from './config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,aAAa,EACb,WAAW,EACX,WAAW,EACX,gBAAgB,GACjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EACL,cAAc,EACd,cAAc,EACd,KAAK,qBAAqB,EAC1B,KAAK,KAAK,GACX,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,YAAY,EACZ,eAAe,EACf,KAAK,yBAAyB,EAC9B,KAAK,gBAAgB,GACtB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { PostgresObservationStore } from './store.js';
+export { MonitorService, mapProbeResult, } from './service.js';
+export { defineConfig, normalizeConfig, } from './config.js';

package/dist/monitor.d.ts

@@ -0,0 +1,22 @@
+import type { CheckResult } from './types.js';
+export interface SparqlMonitorOptions {
+    /** Timeout in milliseconds for the SPARQL request. */
+    timeoutMs?: number;
+    /** HTTP headers to include in requests (e.g., User-Agent). */
+    headers?: Headers;
+}
+/**
+ * Executes SPARQL queries against an endpoint and measures response time.
+ */
+export declare class SparqlMonitor {
+    private readonly fetcher;
+    private readonly options?;
+    constructor(options?: SparqlMonitorOptions);
+    /**
+     * Execute a SPARQL query against an endpoint and return the result.
+     */
+    check(endpointUrl: URL, query: string): Promise<CheckResult>;
+    private prepareFetcherForUrl;
+    private consumeStream;
+}
+//# sourceMappingURL=monitor.d.ts.map

package/dist/monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitor.d.ts","sourceRoot":"","sources":["../src/monitor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AA8B9C,MAAM,WAAW,oBAAoB;IACnC,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8DAA8D;IAC9D,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAuB;gBAEpC,OAAO,CAAC,EAAE,oBAAoB;IAQ1C;;OAEG;IACG,KAAK,CAAC,WAAW,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAyClE,OAAO,CAAC,oBAAoB;YAuBd,aAAa;CAW5B"}

package/dist/monitor.js

@@ -0,0 +1,92 @@
+import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
+/**
+ * Extract credentials from a URL and convert them to a Basic auth header.
+ * Returns a tuple of [URL without credentials, Headers with Authorization].
+ */
+function extractUrlCredentials(url, baseHeaders) {
+    const headers = new Headers(baseHeaders);
+    if (url.username || url.password) {
+        const credentials = `${decodeURIComponent(url.username)}:${decodeURIComponent(url.password)}`;
+        headers.set('Authorization', `Basic ${Buffer.from(credentials).toString('base64')}`);
+        const cleanUrl = new URL(url.toString());
+        cleanUrl.username = '';
+        cleanUrl.password = '';
+        return [cleanUrl, headers];
+    }
+    return [url, headers];
+}
+/**
+ * Executes SPARQL queries against an endpoint and measures response time.
+ */
+export class SparqlMonitor {
+    fetcher;
+    options;
+    constructor(options) {
+        this.options = options;
+        this.fetcher = new SparqlEndpointFetcher({
+            timeout: options?.timeoutMs ?? 30000,
+            defaultHeaders: options?.headers,
+        });
+    }
+    /**
+     * Execute a SPARQL query against an endpoint and return the result.
+     */
+    async check(endpointUrl, query) {
+        const observedAt = new Date(); // UTC
+        const startTime = performance.now();
+        const [url, fetcher] = this.prepareFetcherForUrl(endpointUrl);
+        try {
+            const queryType = fetcher.getQueryType(query);
+            switch (queryType) {
+                case 'ASK':
+                    await fetcher.fetchAsk(url, query);
+                    break;
+                case 'SELECT':
+                    await this.consumeStream(await fetcher.fetchBindings(url, query));
+                    break;
+                case 'CONSTRUCT':
+                    await this.consumeStream(await fetcher.fetchTriples(url, query));
+                    break;
+            }
+            const responseTimeMs = Math.round(performance.now() - startTime);
+            return {
+                success: true,
+                responseTimeMs,
+                errorMessage: null,
+                observedAt,
+            };
+        }
+        catch (error) {
+            const responseTimeMs = Math.round(performance.now() - startTime);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                responseTimeMs,
+                errorMessage,
+                observedAt,
+            };
+        }
+    }
+    prepareFetcherForUrl(endpointUrl) {
+        const [url, headers] = extractUrlCredentials(endpointUrl, this.options?.headers);
+        const hasCredentials = headers.has('Authorization') &&
+            !this.options?.headers?.has('Authorization');
+        if (!hasCredentials) {
+            return [url.toString(), this.fetcher];
+        }
+        const fetcher = new SparqlEndpointFetcher({
+            timeout: this.options?.timeoutMs ?? 30000,
+            defaultHeaders: headers,
+        });
+        return [url.toString(), fetcher];
+    }
+    async consumeStream(stream) {
+        return new Promise((resolve, reject) => {
+            stream.on('data', () => {
+                // Just consume the data
+            });
+            stream.on('end', () => resolve());
+            stream.on('error', reject);
+        });
+    }
+}

package/dist/schema.d.ts

@@ -0,0 +1,200 @@
+/**
+ * Observations table — maps to SOSA Observation concept.
+ */
+export declare const observations: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "observations";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgBuildColumn<"observations", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgUUIDBuilder>>>, {
+            name: string;
+            tableName: "observations";
+            dataType: "string uuid";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        observedAt: import("drizzle-orm/pg-core").PgBuildColumn<"observations", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>>, {
+            name: string;
+            tableName: "observations";
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        monitor: import("drizzle-orm/pg-core").PgBuildColumn<"observations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "observations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        success: import("drizzle-orm/pg-core").PgBuildColumn<"observations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBooleanBuilder>, {
+            name: string;
+            tableName: "observations";
+            dataType: "boolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        responseTimeMs: import("drizzle-orm/pg-core").PgBuildColumn<"observations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>, {
+            name: string;
+            tableName: "observations";
+            dataType: "number int32";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        errorMessage: import("drizzle-orm/pg-core").PgBuildColumn<"observations", import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, {
+            name: string;
+            tableName: "observations";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: "pg";
+}>;
+/**
+ * SQL for refreshing the materialized view.
+ */
+export declare const refreshLatestObservationsViewSql: import("drizzle-orm").SQL<unknown>;
+/**
+ * Materialized view for the latest observation per monitor.
+ */
+export declare const latestObservations: import("drizzle-orm/pg-core").PgMaterializedViewWithSelection<"latest_observations", false, {
+    id: import("drizzle-orm/pg-core").PgBuildColumn<"latest_observations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgUUIDBuilder>, {
+        name: string;
+        tableName: "latest_observations";
+        dataType: "string uuid";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        identity: undefined;
+        generated: undefined;
+    }>;
+    monitor: import("drizzle-orm/pg-core").PgBuildColumn<"latest_observations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>>, {
+        name: string;
+        tableName: "latest_observations";
+        dataType: "string";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        identity: undefined;
+        generated: undefined;
+    }>;
+    observedAt: import("drizzle-orm/pg-core").PgBuildColumn<"latest_observations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgTimestampBuilder>, {
+        name: string;
+        tableName: "latest_observations";
+        dataType: "object date";
+        data: Date;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        identity: undefined;
+        generated: undefined;
+    }>;
+    success: import("drizzle-orm/pg-core").PgBuildColumn<"latest_observations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBooleanBuilder>, {
+        name: string;
+        tableName: "latest_observations";
+        dataType: "boolean";
+        data: boolean;
+        driverParam: boolean;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        identity: undefined;
+        generated: undefined;
+    }>;
+    responseTimeMs: import("drizzle-orm/pg-core").PgBuildColumn<"latest_observations", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgIntegerBuilder>, {
+        name: string;
+        tableName: "latest_observations";
+        dataType: "number int32";
+        data: number;
+        driverParam: string | number;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        identity: undefined;
+        generated: undefined;
+    }>;
+    errorMessage: import("drizzle-orm/pg-core").PgBuildColumn<"latest_observations", import("drizzle-orm/pg-core").PgTextBuilder<[string, ...string[]]>, {
+        name: string;
+        tableName: "latest_observations";
+        dataType: "string";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        identity: undefined;
+        generated: undefined;
+    }>;
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAqBA;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAexB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gCAAgC,oCAE5C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO7B,CAAC"}

package/dist/schema.js

@@ -0,0 +1,36 @@
+import { boolean, index, integer, pgMaterializedView, pgTable, text, timestamp, uuid, } from 'drizzle-orm/pg-core';
+import { sql } from 'drizzle-orm';
+const columns = {
+    id: uuid('id').notNull(),
+    monitor: text('monitor').notNull(),
+    observedAt: timestamp('observed_at', { mode: 'date' }).notNull(),
+    success: boolean('success').notNull(),
+    responseTimeMs: integer('response_time_ms').notNull(),
+    errorMessage: text('error_message'),
+};
+/**
+ * Observations table — maps to SOSA Observation concept.
+ */
+export const observations = pgTable('observations', {
+    ...columns,
+    id: columns.id.primaryKey().defaultRandom(),
+    observedAt: columns.observedAt.defaultNow(),
+}, (table) => [
+    index('observations_monitor_idx').on(table.monitor),
+    index('observations_observed_at_idx').on(table.observedAt),
+    index('observations_monitor_observed_at_idx').on(table.monitor, sql `${table.observedAt} DESC`),
+]);
+/**
+ * SQL for refreshing the materialized view.
+ */
+export const refreshLatestObservationsViewSql = sql `
+  REFRESH MATERIALIZED VIEW CONCURRENTLY latest_observations
+`;
+/**
+ * Materialized view for the latest observation per monitor.
+ */
+export const latestObservations = pgMaterializedView('latest_observations', columns).as(sql `
+  SELECT DISTINCT ON (monitor) *
+  FROM ${observations}
+  ORDER BY monitor, observed_at DESC
+`);

package/dist/service.d.ts

@@ -0,0 +1,72 @@
+import { probe, type ProbeResultType } from '@lde/distribution-probe';
+import type { CheckResult, MonitorConfig, ObservationStore } from './types.js';
+/**
+ * Function signature for a probe. Matches `probe()` from
+ * `@lde/distribution-probe`; injectable so tests can stub it.
+ */
+export type Probe = typeof probe;
+export interface MonitorServiceOptions {
+    /** Store for persisting observations. */
+    store: ObservationStore;
+    /** Monitor configurations. */
+    monitors: MonitorConfig[];
+    /** Polling interval in seconds (default: 300). */
+    intervalSeconds?: number;
+    /** Request timeout in milliseconds passed to the probe (default: 30 000). */
+    timeoutMs?: number;
+    /** HTTP headers forwarded to every probe request (e.g. User-Agent). */
+    headers?: Headers;
+    /**
+     * Override the probe function. Mostly useful for tests; defaults to
+     * {@link probe} from `@lde/distribution-probe`.
+     */
+    probe?: Probe;
+}
+/**
+ * Orchestrates monitoring of multiple DCAT distributions.
+ */
+export declare class MonitorService {
+    private readonly store;
+    private readonly probe;
+    private readonly configs;
+    private readonly intervalSeconds;
+    private readonly timeoutMs;
+    private readonly headers?;
+    private job;
+    constructor(options: MonitorServiceOptions);
+    /**
+     * Perform an immediate check for a monitor.
+     */
+    checkNow(identifier: string): Promise<void>;
+    /**
+     * Perform an immediate check for all monitors.
+     */
+    checkAll(): Promise<void>;
+    /**
+     * Start monitoring all configured distributions.
+     */
+    start(): void;
+    /**
+     * Stop monitoring.
+     */
+    stop(): void;
+    /**
+     * Check whether monitoring is running.
+     */
+    isRunning(): boolean;
+    /**
+     * Convert seconds to a cron expression.
+     */
+    private secondsToCron;
+    private performCheck;
+    private refreshView;
+}
+/**
+ * Collapse a {@link ProbeResultType} into a {@link CheckResult}. Network
+ * errors become `success: false` with the network error message; HTTP or
+ * body-validation failures become `success: false` with the probe's
+ * failureReason (falling back to joined warnings or the HTTP status) as the
+ * error message; everything else is `success: true`.
+ */
+export declare function mapProbeResult(result: ProbeResultType, observedAt: Date): CheckResult;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EAEL,KAAK,eAAe,EAErB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAE/E;;;GAGG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC;AAEjC,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,KAAK,EAAE,gBAAgB,CAAC;IACxB,8BAA8B;IAC9B,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,kDAAkD;IAClD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAID;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAC1C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAU;IACnC,OAAO,CAAC,GAAG,CAAwB;gBAEvB,OAAO,EAAE,qBAAqB;IAS1C;;OAEG;IACG,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASjD;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAK/B;;OAEG;IACH,KAAK,IAAI,IAAI;IAQb;;OAEG;IACH,IAAI,IAAI,IAAI;IAOZ;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,OAAO,CAAC,aAAa;YAYP,YAAY;YAWZ,WAAW;CAO1B;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,eAAe,EACvB,UAAU,EAAE,IAAI,GACf,WAAW,CA+Bb"}

package/dist/service.js

@@ -0,0 +1,134 @@
+import { CronJob } from 'cron';
+import { probe, NetworkError, } from '@lde/distribution-probe';
+const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * Orchestrates monitoring of multiple DCAT distributions.
+ */
+export class MonitorService {
+    store;
+    probe;
+    configs;
+    intervalSeconds;
+    timeoutMs;
+    headers;
+    job = null;
+    constructor(options) {
+        this.store = options.store;
+        this.probe = options.probe ?? probe;
+        this.configs = options.monitors;
+        this.intervalSeconds = options.intervalSeconds ?? 300;
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.headers = options.headers;
+    }
+    /**
+     * Perform an immediate check for a monitor.
+     */
+    async checkNow(identifier) {
+        const config = this.configs.find((c) => c.identifier === identifier);
+        if (!config) {
+            throw new Error(`Monitor not found: ${identifier}`);
+        }
+        await this.performCheck(config);
+        await this.refreshView();
+    }
+    /**
+     * Perform an immediate check for all monitors.
+     */
+    async checkAll() {
+        await Promise.all(this.configs.map((config) => this.performCheck(config)));
+        await this.refreshView();
+    }
+    /**
+     * Start monitoring all configured distributions.
+     */
+    start() {
+        if (!this.job) {
+            const cronExpression = this.secondsToCron(this.intervalSeconds);
+            this.job = new CronJob(cronExpression, () => this.checkAll());
+            this.job.start();
+        }
+    }
+    /**
+     * Stop monitoring.
+     */
+    stop() {
+        if (this.job) {
+            this.job.stop();
+            this.job = null;
+        }
+    }
+    /**
+     * Check whether monitoring is running.
+     */
+    isRunning() {
+        return this.job !== null;
+    }
+    /**
+     * Convert seconds to a cron expression.
+     */
+    secondsToCron(seconds) {
+        if (seconds < 60) {
+            return `*/${seconds} * * * * *`;
+        }
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60) {
+            return `0 */${minutes} * * * *`;
+        }
+        const hours = Math.floor(minutes / 60);
+        return `0 0 */${hours} * * *`;
+    }
+    async performCheck(config) {
+        const observedAt = new Date();
+        const options = { timeoutMs: this.timeoutMs };
+        if (this.headers)
+            options.headers = this.headers;
+        if (config.sparqlQuery)
+            options.sparqlQuery = config.sparqlQuery;
+        const result = await this.probe(config.distribution, options);
+        const checkResult = mapProbeResult(result, observedAt);
+        await this.store.store({ monitor: config.identifier, ...checkResult });
+    }
+    async refreshView() {
+        try {
+            await this.store.refreshLatestObservationsView();
+        }
+        catch {
+            // View refresh failure is not critical
+        }
+    }
+}
+/**
+ * Collapse a {@link ProbeResultType} into a {@link CheckResult}. Network
+ * errors become `success: false` with the network error message; HTTP or
+ * body-validation failures become `success: false` with the probe's
+ * failureReason (falling back to joined warnings or the HTTP status) as the
+ * error message; everything else is `success: true`.
+ */
+export function mapProbeResult(result, observedAt) {
+    if (result instanceof NetworkError) {
+        return {
+            success: false,
+            responseTimeMs: result.responseTimeMs,
+            errorMessage: result.message,
+            observedAt,
+        };
+    }
+    if (result.isSuccess()) {
+        return {
+            success: true,
+            responseTimeMs: result.responseTimeMs,
+            errorMessage: null,
+            observedAt,
+        };
+    }
+    const errorMessage = result.failureReason ??
+        (result.warnings.length > 0
+            ? result.warnings.join('; ')
+            : `HTTP ${result.statusCode} ${result.statusText}`);
+    return {
+        success: false,
+        responseTimeMs: result.responseTimeMs,
+        errorMessage,
+        observedAt,
+    };
+}

package/dist/store.d.ts

@@ -0,0 +1,23 @@
+import type { ObservationStore, Observation } from './types.js';
+/**
+ * PostgreSQL implementation of the ObservationStore interface.
+ */
+export declare class PostgresObservationStore implements ObservationStore {
+    private db;
+    private constructor();
+    /**
+     * Create a new store and initialize the database schema.
+     *
+     * Uses drizzle-kit's generateMigration to create schema from code.
+     * This approach works around a bug in pushSchema where the execute()
+     * return format doesn't match what drizzle-kit expects.
+     * See: https://github.com/drizzle-team/drizzle-orm/issues/5293
+     */
+    static create(connectionString: string): Promise<PostgresObservationStore>;
+    close(): Promise<void>;
+    getLatest(): Promise<Map<string, Observation>>;
+    get(id: string): Promise<Observation | null>;
+    store(observation: Omit<Observation, 'id'>): Promise<Observation>;
+    refreshLatestObservationsView(): Promise<void>;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAKhE;;GAEG;AACH,qBAAa,wBAAyB,YAAW,gBAAgB;IAC/D,OAAO,CAAC,EAAE,CAAqB;IAE/B,OAAO;IAIP;;;;;;;OAOG;WACU,MAAM,CACjB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,wBAAwB,CAAC;IAwC9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAK9C,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAS5C,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC;IAQjE,6BAA6B,IAAI,OAAO,CAAC,IAAI,CAAC;CAGrD"}

package/dist/store.js

@@ -0,0 +1,84 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import { eq, sql } from 'drizzle-orm';
+import * as schema from './schema.js';
+const { observations, latestObservations, refreshLatestObservationsViewSql } = schema;
+/**
+ * PostgreSQL implementation of the ObservationStore interface.
+ */
+export class PostgresObservationStore {
+    db;
+    constructor(connectionString) {
+        this.db = drizzle(connectionString);
+    }
+    /**
+     * Create a new store and initialize the database schema.
+     *
+     * Uses drizzle-kit's generateMigration to create schema from code.
+     * This approach works around a bug in pushSchema where the execute()
+     * return format doesn't match what drizzle-kit expects.
+     * See: https://github.com/drizzle-team/drizzle-orm/issues/5293
+     */
+    static async create(connectionString) {
+        const store = new PostgresObservationStore(connectionString);
+        const { generateDrizzleJson, generateMigration } = await import('drizzle-kit/api-postgres');
+        // Generate migration from empty state to our schema
+        const empty = await generateDrizzleJson({});
+        const target = await generateDrizzleJson(schema, empty.id);
+        const migration = await generateMigration(empty, target);
+        // Execute each statement, ignoring "already exists" errors for idempotency
+        for (const statement of migration) {
+            try {
+                await store.db.execute(sql.raw(statement));
+            }
+            catch (error) {
+                // Check both direct error and cause for "already exists"
+                const isAlreadyExists = (e) => {
+                    if (!(e instanceof Error))
+                        return false;
+                    if (e.message.includes('already exists'))
+                        return true;
+                    if ('cause' in e)
+                        return isAlreadyExists(e.cause);
+                    return false;
+                };
+                if (!isAlreadyExists(error)) {
+                    throw error;
+                }
+            }
+        }
+        // Create unique index on materialized view for CONCURRENTLY refresh
+        try {
+            await store.db.execute(sql `CREATE UNIQUE INDEX latest_observations_monitor_idx ON latest_observations (monitor)`);
+        }
+        catch {
+            // Index may already exist
+        }
+        return store;
+    }
+    async close() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await this.db.$client.end();
+    }
+    async getLatest() {
+        const rows = await this.db.select().from(latestObservations);
+        return new Map(rows.map((row) => [row.monitor, row]));
+    }
+    async get(id) {
+        const rows = await this.db
+            .select()
+            .from(observations)
+            .where(eq(observations.id, id))
+            .limit(1);
+        return rows[0] ?? null;
+    }
+    async store(observation) {
+        const rows = await this.db
+            .insert(observations)
+            .values(observation)
+            .returning();
+        return rows[0];
+    }
+    async refreshLatestObservationsView() {
+        await this.db.execute(refreshLatestObservationsViewSql);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,71 @@
+import { Distribution } from '@lde/dataset';
+/**
+ * Configuration for a single monitor.
+ *
+ * Monitors target any DCAT {@link Distribution}: a SPARQL endpoint (in which
+ * case `sparqlQuery` is used for the probe) or a data dump (in which case
+ * `sparqlQuery` is ignored and the distribution is fetched with HEAD/GET).
+ */
+export interface MonitorConfig {
+    /** Unique identifier for this monitor. */
+    identifier: string;
+    /** The DCAT distribution to probe. */
+    distribution: Distribution;
+    /**
+     * SPARQL query to run against the endpoint. Only meaningful when the
+     * distribution is a SPARQL endpoint. Defaults to a minimal availability
+     * probe (`SELECT * { ?s ?p ?o } LIMIT 1`).
+     */
+    sparqlQuery?: string;
+}
+/**
+ * Result of a single check against a distribution.
+ */
+export interface CheckResult {
+    /** Whether the distribution responded successfully. */
+    success: boolean;
+    /** Response time in milliseconds. */
+    responseTimeMs: number;
+    /** Error message if the check failed. */
+    errorMessage: string | null;
+    /** Timestamp when the response was received (UTC). */
+    observedAt: Date;
+}
+/**
+ * Observation record from the database.
+ */
+export interface Observation {
+    id: string;
+    monitor: string;
+    observedAt: Date;
+    success: boolean;
+    responseTimeMs: number;
+    errorMessage: string | null;
+}
+/**
+ * Store interface for persisting observations.
+ */
+export interface ObservationStore {
+    /**
+     * Get the latest observation for each identifier.
+     * Returns a map keyed by identifier.
+     */
+    getLatest(): Promise<Map<string, Observation>>;
+    /**
+     * Get a specific observation by ID.
+     */
+    get(id: string): Promise<Observation | null>;
+    /**
+     * Save a new observation.
+     */
+    store(observation: Omit<Observation, 'id'>): Promise<Observation>;
+    /**
+     * Refresh the latest_observations materialized view.
+     */
+    refreshLatestObservationsView(): Promise<void>;
+    /**
+     * Close the database connection.
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,YAAY,EAAE,YAAY,CAAC;IAC3B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,uDAAuD;IACvD,OAAO,EAAE,OAAO,CAAC;IACjB,qCAAqC;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,sDAAsD;IACtD,UAAU,EAAE,IAAI,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,IAAI,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,SAAS,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;IAE/C;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IAE7C;;OAEG;IACH,KAAK,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAElE;;OAEG;IACH,6BAA6B,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE/C;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@lde/distribution-monitor",
+  "version": "0.1.1",
+  "description": "Monitor DCAT distributions (SPARQL endpoints and data dumps) with periodic probes",
+  "repository": {
+    "url": "git+https://github.com/ldelements/lde.git",
+    "directory": "packages/distribution-monitor"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "development": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "distribution-monitor": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "@lde/dataset": "0.7.3",
+    "@lde/distribution-probe": "0.1.2",
+    "c12": "^3.3.4",
+    "commander": "^14.0.3",
+    "cron": "^4.1.0",
+    "drizzle-kit": "1.0.0-beta.20",
+    "drizzle-orm": "1.0.0-beta.22-41a7d21",
+    "postgres": "^3.4.9",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "@testcontainers/postgresql": "^11.14.0"
+  }
+}