@f0rbit/corpus 0.1.4 → 0.1.6

package/dist/observations/schema.d.ts

@@ -0,0 +1,267 @@
+/**
+ * @module ObservationSchema
+ * @description Database schema definitions for observations using Drizzle ORM.
+ */
+/**
+ * Drizzle ORM schema for the corpus_observations table.
+ *
+ * Used by the Cloudflare backend with D1 (SQLite). Defines the table structure
+ * for storing observation metadata linking structured facts to versioned content.
+ *
+ * Columns:
+ * - `id` - Primary key (unique observation identifier)
+ * - `type` - Observation type name (e.g., 'entity_mention')
+ * - `source_store_id` + `source_version` - Points to the snapshot this observation is about
+ * - `source_path` - Optional JSONPath expression to specific element
+ * - `source_span_start` / `source_span_end` - Optional character range within text
+ * - `content` - JSON-encoded observation data
+ * - `confidence` - Optional confidence score (0.0 to 1.0)
+ * - `observed_at` - When the observation was made (ISO 8601)
+ * - `created_at` - When the record was stored (ISO 8601)
+ * - `derived_from` - Optional JSON array of SnapshotPointers for provenance
+ *
+ * @example
+ * ```ts
+ * import { drizzle } from 'drizzle-orm/d1'
+ * import { corpus_observations } from 'corpus/observation-schema'
+ *
+ * const db = drizzle(env.D1)
+ * const rows = await db.select().from(corpus_observations).where(eq(corpus_observations.type, 'entity_mention'))
+ * ```
+ */
+export declare const corpus_observations: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "corpus_observations";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        type: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "type";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        source_store_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_store_id";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        source_version: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_version";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        source_path: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_path";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        source_span_start: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_span_start";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        source_span_end: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_span_end";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        confidence: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "confidence";
+            tableName: "corpus_observations";
+            dataType: "number";
+            columnType: "SQLiteReal";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        observed_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "observed_at";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        derived_from: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "derived_from";
+            tableName: "corpus_observations";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+export type ObservationRow = typeof corpus_observations.$inferSelect;
+export type ObservationInsert = typeof corpus_observations.$inferInsert;
+//# sourceMappingURL=schema.d.ts.map

package/dist/observations/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../observations/schema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B7B,CAAA;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAA;AACpE,MAAM,MAAM,iBAAiB,GAAG,OAAO,mBAAmB,CAAC,YAAY,CAAA"}

package/dist/observations/schema.js

@@ -0,0 +1,55 @@
+/**
+ * @module ObservationSchema
+ * @description Database schema definitions for observations using Drizzle ORM.
+ */
+import { sqliteTable, text, real, index } from 'drizzle-orm/sqlite-core';
+/**
+ * Drizzle ORM schema for the corpus_observations table.
+ *
+ * Used by the Cloudflare backend with D1 (SQLite). Defines the table structure
+ * for storing observation metadata linking structured facts to versioned content.
+ *
+ * Columns:
+ * - `id` - Primary key (unique observation identifier)
+ * - `type` - Observation type name (e.g., 'entity_mention')
+ * - `source_store_id` + `source_version` - Points to the snapshot this observation is about
+ * - `source_path` - Optional JSONPath expression to specific element
+ * - `source_span_start` / `source_span_end` - Optional character range within text
+ * - `content` - JSON-encoded observation data
+ * - `confidence` - Optional confidence score (0.0 to 1.0)
+ * - `observed_at` - When the observation was made (ISO 8601)
+ * - `created_at` - When the record was stored (ISO 8601)
+ * - `derived_from` - Optional JSON array of SnapshotPointers for provenance
+ *
+ * @example
+ * ```ts
+ * import { drizzle } from 'drizzle-orm/d1'
+ * import { corpus_observations } from 'corpus/observation-schema'
+ *
+ * const db = drizzle(env.D1)
+ * const rows = await db.select().from(corpus_observations).where(eq(corpus_observations.type, 'entity_mention'))
+ * ```
+ */
+export const corpus_observations = sqliteTable('corpus_observations', {
+    id: text('id').primaryKey(),
+    type: text('type').notNull(),
+    // Source pointer
+    source_store_id: text('source_store_id').notNull(),
+    source_version: text('source_version').notNull(),
+    source_path: text('source_path'),
+    source_span_start: text('source_span_start'),
+    source_span_end: text('source_span_end'),
+    // Content
+    content: text('content').notNull(),
+    confidence: real('confidence'),
+    // Timestamps
+    observed_at: text('observed_at'),
+    created_at: text('created_at').notNull(),
+    // Derivation lineage
+    derived_from: text('derived_from'),
+}, (table) => ({
+    type_idx: index('idx_obs_type').on(table.type),
+    source_idx: index('idx_obs_source').on(table.source_store_id, table.source_version),
+    type_observed_idx: index('idx_obs_type_observed').on(table.type, table.observed_at),
+    type_source_idx: index('idx_obs_type_source').on(table.type, table.source_store_id),
+}));

package/dist/observations/storage.d.ts

@@ -0,0 +1,75 @@
+/**
+ * @module ObservationsStorage
+ * @description Raw storage interface and row conversion utilities for observations.
+ */
+import type { Result, CorpusError } from '../types';
+import type { ObservationRow } from './schema';
+import type { Observation, ObservationMeta, SnapshotPointer } from './types';
+/**
+ * Query options for raw storage operations.
+ * Dates are ISO strings at the storage layer.
+ */
+export type StorageQueryOpts = {
+    type?: string | string[];
+    source_store_id?: string;
+    source_version?: string;
+    source_prefix?: string;
+    created_after?: string;
+    created_before?: string;
+    observed_after?: string;
+    observed_before?: string;
+    limit?: number;
+};
+/**
+ * Raw storage adapter for observation rows.
+ * Backends implement this thin interface; all business logic lives in the client.
+ */
+export type ObservationsStorage = {
+    /** Store a row. Returns the row on success. */
+    put_row: (row: ObservationRow) => Promise<Result<ObservationRow, CorpusError>>;
+    /** Get a row by ID. Returns null if not found. */
+    get_row: (id: string) => Promise<Result<ObservationRow | null, CorpusError>>;
+    /** Query rows with optional filters. */
+    query_rows: (opts?: StorageQueryOpts) => AsyncIterable<ObservationRow>;
+    /** Delete a row by ID. Returns true if deleted, false if not found. */
+    delete_row: (id: string) => Promise<Result<boolean, CorpusError>>;
+    /** Delete rows matching source. Returns count deleted. */
+    delete_by_source: (store_id: string, version: string, path?: string) => Promise<Result<number, CorpusError>>;
+};
+/**
+ * Convert a storage row to an Observation (includes content).
+ */
+export declare function row_to_observation(row: ObservationRow): Observation;
+/**
+ * Convert a storage row to ObservationMeta (excludes content).
+ */
+export declare function row_to_meta(row: ObservationRow): ObservationMeta;
+/**
+ * Create an ObservationRow from put options.
+ */
+export declare function create_observation_row(id: string, type_name: string, source: SnapshotPointer, content: unknown, opts: {
+    confidence?: number;
+    observed_at?: Date;
+    derived_from?: SnapshotPointer[];
+}): ObservationRow;
+/**
+ * Filter and sort observation rows based on query options.
+ * Used by in-memory storage implementations (memory backend, file backend).
+ */
+export declare function filter_observation_rows(rows: ObservationRow[], opts?: StorageQueryOpts): ObservationRow[];
+/**
+ * Simple CRUD interface for observation storage backends.
+ */
+export type ObservationsCRUD = {
+    get_all: () => Promise<ObservationRow[]>;
+    set_all: (rows: ObservationRow[]) => Promise<void>;
+    get_one: (id: string) => Promise<ObservationRow | null>;
+    add_one: (row: ObservationRow) => Promise<void>;
+    remove_one: (id: string) => Promise<boolean>;
+};
+/**
+ * Create an ObservationsStorage from simple CRUD operations.
+ * Used by memory and file backends.
+ */
+export declare function create_observations_storage(crud: ObservationsCRUD): ObservationsStorage;
+//# sourceMappingURL=storage.d.ts.map

package/dist/observations/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../../observations/storage.ts"],"names":[],"mappings":"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"}

package/dist/observations/storage.js

@@ -0,0 +1,137 @@
+/**
+ * @module ObservationsStorage
+ * @description Raw storage interface and row conversion utilities for observations.
+ */
+import { ok } from '../types';
+/**
+ * Extract common fields from an observation row (everything except content).
+ * Used internally by row_to_observation and row_to_meta.
+ */
+function row_to_base(row) {
+    return {
+        id: row.id,
+        type: row.type,
+        source: {
+            store_id: row.source_store_id,
+            version: row.source_version,
+            ...(row.source_path && { path: row.source_path }),
+            ...(row.source_span_start && row.source_span_end && {
+                span: {
+                    start: parseInt(row.source_span_start, 10),
+                    end: parseInt(row.source_span_end, 10)
+                }
+            })
+        },
+        ...(row.confidence !== null && { confidence: row.confidence }),
+        ...(row.observed_at && { observed_at: new Date(row.observed_at) }),
+        created_at: new Date(row.created_at),
+        ...(row.derived_from && { derived_from: JSON.parse(row.derived_from) })
+    };
+}
+/**
+ * Convert a storage row to an Observation (includes content).
+ */
+export function row_to_observation(row) {
+    return {
+        ...row_to_base(row),
+        content: JSON.parse(row.content)
+    };
+}
+/**
+ * Convert a storage row to ObservationMeta (excludes content).
+ */
+export function row_to_meta(row) {
+    return row_to_base(row);
+}
+/**
+ * Create an ObservationRow from put options.
+ */
+export function create_observation_row(id, type_name, source, content, opts) {
+    const now = new Date();
+    return {
+        id,
+        type: type_name,
+        source_store_id: source.store_id,
+        source_version: source.version,
+        source_path: source.path ?? null,
+        source_span_start: source.span?.start?.toString() ?? null,
+        source_span_end: source.span?.end?.toString() ?? null,
+        content: JSON.stringify(content),
+        confidence: opts.confidence ?? null,
+        observed_at: opts.observed_at?.toISOString() ?? null,
+        created_at: now.toISOString(),
+        derived_from: opts.derived_from ? JSON.stringify(opts.derived_from) : null
+    };
+}
+/**
+ * Filter and sort observation rows based on query options.
+ * Used by in-memory storage implementations (memory backend, file backend).
+ */
+export function filter_observation_rows(rows, opts = {}) {
+    let filtered = rows;
+    if (opts.type) {
+        const types = Array.isArray(opts.type) ? opts.type : [opts.type];
+        filtered = filtered.filter(r => types.includes(r.type));
+    }
+    if (opts.source_store_id) {
+        filtered = filtered.filter(r => r.source_store_id === opts.source_store_id);
+    }
+    if (opts.source_version) {
+        filtered = filtered.filter(r => r.source_version === opts.source_version);
+    }
+    if (opts.source_prefix) {
+        filtered = filtered.filter(r => r.source_version.startsWith(opts.source_prefix));
+    }
+    if (opts.created_after) {
+        filtered = filtered.filter(r => r.created_at > opts.created_after);
+    }
+    if (opts.created_before) {
+        filtered = filtered.filter(r => r.created_at < opts.created_before);
+    }
+    if (opts.observed_after) {
+        filtered = filtered.filter(r => r.observed_at && r.observed_at > opts.observed_after);
+    }
+    if (opts.observed_before) {
+        filtered = filtered.filter(r => r.observed_at && r.observed_at < opts.observed_before);
+    }
+    filtered.sort((a, b) => b.created_at.localeCompare(a.created_at));
+    if (opts.limit) {
+        filtered = filtered.slice(0, opts.limit);
+    }
+    return filtered;
+}
+/**
+ * Create an ObservationsStorage from simple CRUD operations.
+ * Used by memory and file backends.
+ */
+export function create_observations_storage(crud) {
+    return {
+        async put_row(row) {
+            await crud.add_one(row);
+            return ok(row);
+        },
+        async get_row(id) {
+            const row = await crud.get_one(id);
+            return ok(row);
+        },
+        async *query_rows(opts = {}) {
+            const rows = filter_observation_rows(await crud.get_all(), opts);
+            for (const row of rows) {
+                yield row;
+            }
+        },
+        async delete_row(id) {
+            const deleted = await crud.remove_one(id);
+            return ok(deleted);
+        },
+        async delete_by_source(store_id, version, path) {
+            const rows = await crud.get_all();
+            const toKeep = rows.filter(r => !(r.source_store_id === store_id &&
+                r.source_version === version &&
+                (path === undefined || r.source_path === path)));
+            const deleted = rows.length - toKeep.length;
+            await crud.set_all(toKeep);
+            return ok(deleted);
+        }
+    };
+}