@lde/sparql-monitor 0.1.0

package/README.md

@@ -0,0 +1,80 @@
+# SPARQL Monitor
+
+Monitor SPARQL endpoints with periodic checks, storing observations in PostgreSQL.
+
+## Installation
+
+```bash
+npm install @lde/sparql-monitor
+```
+
+## Usage
+
+```typescript
+import {
+  MonitorService,
+  PostgresObservationStore,
+  type MonitorConfig,
+} from '@lde/sparql-monitor';
+
+// Define monitors
+const monitors: MonitorConfig[] = [
+  {
+    identifier: 'dbpedia',
+    endpointUrl: new URL('https://dbpedia.org/sparql'),
+    query: 'ASK { ?s ?p ?o }',
+  },
+  {
+    identifier: 'wikidata',
+    endpointUrl: new URL('https://query.wikidata.org/sparql'),
+    query: 'SELECT * WHERE { ?s ?p ?o } LIMIT 1',
+  },
+];
+
+// Create store (initializes database schema automatically)
+const store = await PostgresObservationStore.create(
+  'postgres://user:pass@localhost:5432/db'
+);
+
+// Create service with polling interval
+const service = new MonitorService({
+  store,
+  monitors,
+  intervalSeconds: 300, // Check all endpoints every 5 minutes
+});
+
+// Start periodic monitoring
+service.start();
+
+// Or perform immediate checks
+await service.checkAll();
+await service.checkNow('dbpedia');
+
+// Get latest observations
+const observations = await store.getLatest();
+for (const [identifier, observation] of observations) {
+  console.log(
+    `${identifier}: ${observation.success ? 'OK' : 'FAIL'} (${
+      observation.responseTimeMs
+    }ms)`
+  );
+}
+
+// Stop monitoring and close the store
+service.stop();
+await store.close();
+```
+
+## 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.
+
+## Query Types
+
+The monitor supports ASK, SELECT, and CONSTRUCT queries. The check is considered successful if the query executes without error.

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { MonitorConfig, Observation, ObservationStore } from './types.js';
+export { PostgresObservationStore } from './store.js';
+export { MonitorService, type MonitorServiceOptions } from './service.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,EAAE,aAAa,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { PostgresObservationStore } from './store.js';
+export { MonitorService } from './service.js';

package/dist/monitor.d.ts

@@ -0,0 +1,23 @@
+import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
+import type { CheckResult } from './types.js';
+export interface SparqlMonitorOptions {
+    /** Optional custom fetcher instance. */
+    fetcher?: SparqlEndpointFetcher;
+    /** 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;
+    constructor(options?: SparqlMonitorOptions);
+    /**
+     * Execute a SPARQL query against an endpoint and return the result.
+     */
+    check(endpointUrl: URL, query: string): Promise<CheckResult>;
+    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":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,MAAM,WAAW,oBAAoB;IACnC,wCAAwC;IACxC,OAAO,CAAC,EAAE,qBAAqB,CAAC;IAChC,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;gBAEpC,OAAO,CAAC,EAAE,oBAAoB;IAS1C;;OAEG;IACG,KAAK,CAAC,WAAW,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;YA8CpD,aAAa;CAS5B"}

package/dist/monitor.js

@@ -0,0 +1,64 @@
+import { SparqlEndpointFetcher } from 'fetch-sparql-endpoint';
+/**
+ * Executes SPARQL queries against an endpoint and measures response time.
+ */
+export class SparqlMonitor {
+    fetcher;
+    constructor(options) {
+        this.fetcher =
+            options?.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();
+        try {
+            const queryType = this.fetcher.getQueryType(query);
+            switch (queryType) {
+                case 'ASK':
+                    await this.fetcher.fetchAsk(endpointUrl.toString(), query);
+                    break;
+                case 'SELECT':
+                    await this.consumeStream(await this.fetcher.fetchBindings(endpointUrl.toString(), query));
+                    break;
+                case 'CONSTRUCT':
+                    await this.consumeStream(await this.fetcher.fetchTriples(endpointUrl.toString(), query));
+                    break;
+                default:
+                    throw new Error(`Unsupported query type: ${queryType}`);
+            }
+            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,
+            };
+        }
+    }
+    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,224 @@
+/**
+ * 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").PgColumn<{
+            name: "id";
+            tableName: "observations";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        observedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "observed_at";
+            tableName: "observations";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        monitor: import("drizzle-orm/pg-core").PgColumn<{
+            name: "monitor";
+            tableName: "observations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        success: import("drizzle-orm/pg-core").PgColumn<{
+            name: "success";
+            tableName: "observations";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        responseTimeMs: import("drizzle-orm/pg-core").PgColumn<{
+            name: "response_time_ms";
+            tableName: "observations";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        errorMessage: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error_message";
+            tableName: "observations";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            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").PgColumn<{
+        name: "id";
+        tableName: "latest_observations";
+        dataType: "string";
+        columnType: "PgUUID";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    monitor: import("drizzle-orm/pg-core").PgColumn<{
+        name: "monitor";
+        tableName: "latest_observations";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    observedAt: import("drizzle-orm/pg-core").PgColumn<{
+        name: "observed_at";
+        tableName: "latest_observations";
+        dataType: "date";
+        columnType: "PgTimestamp";
+        data: Date;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    success: import("drizzle-orm/pg-core").PgColumn<{
+        name: "success";
+        tableName: "latest_observations";
+        dataType: "boolean";
+        columnType: "PgBoolean";
+        data: boolean;
+        driverParam: boolean;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    responseTimeMs: import("drizzle-orm/pg-core").PgColumn<{
+        name: "response_time_ms";
+        tableName: "latest_observations";
+        dataType: "number";
+        columnType: "PgInteger";
+        data: number;
+        driverParam: string | number;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    errorMessage: import("drizzle-orm/pg-core").PgColumn<{
+        name: "error_message";
+        tableName: "latest_observations";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        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,50 @@
+import { SparqlMonitor } from './monitor.js';
+import type { ObservationStore, MonitorConfig } from './types.js';
+export interface MonitorServiceOptions {
+    /** Store for persisting observations. */
+    store: ObservationStore;
+    /** Monitor configurations. */
+    monitors: MonitorConfig[];
+    /** Polling interval in seconds (default: 300). */
+    intervalSeconds?: number;
+    /** Optional custom monitor instance. */
+    sparqlMonitor?: SparqlMonitor;
+}
+/**
+ * Orchestrates monitoring of multiple SPARQL endpoints.
+ */
+export declare class MonitorService {
+    private readonly store;
+    private readonly sparqlMonitor;
+    private readonly configs;
+    private readonly intervalSeconds;
+    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 endpoints.
+     */
+    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;
+}
+//# 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,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAElE,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,wCAAwC;IACxC,aAAa,CAAC,EAAE,aAAa,CAAC;CAC/B;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAC1C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,GAAG,CAAwB;gBAEvB,OAAO,EAAE,qBAAqB;IAO1C;;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"}

package/dist/service.js

@@ -0,0 +1,90 @@
+import { CronJob } from 'cron';
+import { SparqlMonitor } from './monitor.js';
+/**
+ * Orchestrates monitoring of multiple SPARQL endpoints.
+ */
+export class MonitorService {
+    store;
+    sparqlMonitor;
+    configs;
+    intervalSeconds;
+    job = null;
+    constructor(options) {
+        this.store = options.store;
+        this.sparqlMonitor = options.sparqlMonitor ?? new SparqlMonitor();
+        this.configs = options.monitors;
+        this.intervalSeconds = options.intervalSeconds ?? 300;
+    }
+    /**
+     * 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 endpoints.
+     */
+    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 result = await this.sparqlMonitor.check(config.endpointUrl, config.query);
+        await this.store.store({
+            monitor: config.identifier,
+            ...result,
+        });
+    }
+    async refreshView() {
+        try {
+            await this.store.refreshLatestObservationsView();
+        }
+        catch {
+            // View refresh failure is not critical
+        }
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,19 @@
+import type { ObservationStore, Observation } from './types.js';
+/**
+ * PostgreSQL implementation of the ObservationStore interface.
+ */
+export declare class PostgresObservationStore implements ObservationStore {
+    private client;
+    private db;
+    private constructor();
+    /**
+     * Create a new store and initialize the database schema.
+     */
+    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,MAAM,CAAe;IAC7B,OAAO,CAAC,EAAE,CAAqB;IAE/B,OAAO;IAKP;;OAEG;WACU,MAAM,CACjB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,wBAAwB,CAAC;IAQ9B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,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,51 @@
+import { drizzle } from 'drizzle-orm/postgres-js';
+import { eq } from 'drizzle-orm';
+import postgres from 'postgres';
+import * as schema from './schema.js';
+const { observations, latestObservations, refreshLatestObservationsViewSql } = schema;
+/**
+ * PostgreSQL implementation of the ObservationStore interface.
+ */
+export class PostgresObservationStore {
+    client;
+    db;
+    constructor(connectionString) {
+        this.client = postgres(connectionString);
+        this.db = drizzle(this.client);
+    }
+    /**
+     * Create a new store and initialize the database schema.
+     */
+    static async create(connectionString) {
+        const store = new PostgresObservationStore(connectionString);
+        const { pushSchema } = await import('drizzle-kit/api');
+        const result = await pushSchema(schema, store.db);
+        await result.apply();
+        return store;
+    }
+    async close() {
+        await this.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,62 @@
+/**
+ * Configuration for a monitor.
+ */
+export interface MonitorConfig {
+    /** Unique identifier for this monitor. */
+    identifier: string;
+    /** URL of the SPARQL endpoint to monitor. */
+    endpointUrl: URL;
+    /** SPARQL query to execute. */
+    query: string;
+}
+/**
+ * Result of a single check against a SPARQL endpoint.
+ */
+export interface CheckResult {
+    /** Whether the endpoint 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;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,WAAW,EAAE,GAAG,CAAC;IACjB,+BAA+B;IAC/B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,mDAAmD;IACnD,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,36 @@
+{
+  "name": "@lde/sparql-monitor",
+  "version": "0.1.0",
+  "description": "Monitor SPARQL endpoints with periodic checks",
+  "repository": {
+    "url": "https://github.com/ldengine/lde"
+  },
+  "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",
+  "files": [
+    "dist",
+    "!**/*.tsbuildinfo"
+  ],
+  "dependencies": {
+    "cron": "^4.1.0",
+    "drizzle-kit": "^0.30.4",
+    "drizzle-orm": "^0.38.4",
+    "fetch-sparql-endpoint": "^6.0.0",
+    "postgres": "^3.4.5",
+    "tslib": "^2.3.0"
+  },
+  "devDependencies": {
+    "vite": "^6.0.0"
+  }
+}