@avytheone/efmesh 0.1.0-beta.2 → 0.2.0

package/src/state/postgres.ts

@@ -5,6 +5,7 @@ import type {
   IntervalRecord,
   MigrationReport,
   PlanRecord,
+  RunRecord,
   SnapshotRecord,
   StateStoreShape,
 } from "./store.ts"
@@ -54,6 +55,18 @@ CREATE TABLE IF NOT EXISTS efmesh_state.intervals (
   updated_at  TEXT NOT NULL,
   PRIMARY KEY (snapshot_fp, start_ts)
 );
+CREATE TABLE IF NOT EXISTS efmesh_state.runs (
+  id          INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  env         TEXT NOT NULL,
+  started_at  TEXT NOT NULL,
+  finished_at TEXT NOT NULL,
+  outcome     TEXT NOT NULL,
+  detail      TEXT NOT NULL DEFAULT ''
+);
+CREATE TABLE IF NOT EXISTS efmesh_state.canon_cache (
+  key       TEXT PRIMARY KEY,
+  canonical TEXT NOT NULL
+);
 CREATE TABLE IF NOT EXISTS efmesh_state.locks (
   name        TEXT PRIMARY KEY,
   acquired_at TEXT NOT NULL,
@@ -331,6 +344,42 @@ export const PostgresStateLive = (
             )) as ReadonlyArray<PlanRecord>
           }),
 
+        getCanon: (key) =>
+          attempt("getCanon", async () => {
+            const rows = (await sql.unsafe(
+              `SELECT canonical FROM efmesh_state.canon_cache WHERE key = $1`,
+              [key],
+            )) as ReadonlyArray<{ canonical: string }>
+            return rows[0]?.canonical
+          }),
+
+        putCanon: (key, canonical) =>
+          attempt("putCanon", async () => {
+            await sql.unsafe(
+              `INSERT INTO efmesh_state.canon_cache (key, canonical) VALUES ($1, $2)
+               ON CONFLICT (key) DO NOTHING`,
+              [key, canonical],
+            )
+          }),
+
+        recordRun: (record) =>
+          attempt("recordRun", async () => {
+            await sql.unsafe(
+              `INSERT INTO efmesh_state.runs (env, started_at, finished_at, outcome, detail)
+               VALUES ($1, $2, $3, $4, $5)`,
+              [record.env, record.startedAt, record.finishedAt, record.outcome, record.detail],
+            )
+          }),
+
+        listRuns: (env, limit) =>
+          attempt("listRuns", async () => {
+            return (await sql.unsafe(
+              `SELECT id, env, started_at AS "startedAt", finished_at AS "finishedAt", outcome, detail
+               FROM efmesh_state.runs WHERE env = $1 ORDER BY id DESC LIMIT $2`,
+              [env, limit],
+            )) as ReadonlyArray<RunRecord>
+          }),
+
         acquireLock: (name, ttlMs) =>
           Clock.currentTimeMillis.pipe(
             Effect.flatMap((nowMs) =>

package/src/state/sqlite.ts

@@ -6,6 +6,7 @@ import type {
   IntervalRecord,
   MigrationReport,
   PlanRecord,
+  RunRecord,
   SnapshotRecord,
   StateStoreShape,
 } from "./store.ts"
@@ -46,6 +47,18 @@ CREATE TABLE IF NOT EXISTS intervals (
   updated_at  TEXT NOT NULL,
   PRIMARY KEY (snapshot_fp, start_ts)
 );
+CREATE TABLE IF NOT EXISTS runs (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  env         TEXT NOT NULL,
+  started_at  TEXT NOT NULL,
+  finished_at TEXT NOT NULL,
+  outcome     TEXT NOT NULL,
+  detail      TEXT NOT NULL DEFAULT ''
+);
+CREATE TABLE IF NOT EXISTS canon_cache (
+  key       TEXT PRIMARY KEY,
+  canonical TEXT NOT NULL
+);
 CREATE TABLE IF NOT EXISTS locks (
   name        TEXT PRIMARY KEY,
   acquired_at TEXT NOT NULL,
@@ -342,6 +355,40 @@ export const SqliteStateLive = (
               .all(env) as ReadonlyArray<PlanRecord>
           }),
 
+        getCanon: (key) =>
+          attempt("getCanon", () => {
+            const row = db
+              .query(`SELECT canonical FROM canon_cache WHERE key = ?1`)
+              .get(key) as { canonical: string } | null
+            return row?.canonical ?? undefined
+          }),
+
+        putCanon: (key, canonical) =>
+          attempt("putCanon", () => {
+            db.query(
+              `INSERT INTO canon_cache (key, canonical) VALUES (?1, ?2)
+               ON CONFLICT (key) DO NOTHING`,
+            ).run(key, canonical)
+          }),
+
+        recordRun: (record) =>
+          attempt("recordRun", () => {
+            db.query(
+              `INSERT INTO runs (env, started_at, finished_at, outcome, detail)
+               VALUES (?1, ?2, ?3, ?4, ?5)`,
+            ).run(record.env, record.startedAt, record.finishedAt, record.outcome, record.detail)
+          }),
+
+        listRuns: (env, limit) =>
+          attempt("listRuns", () => {
+            return db
+              .query(
+                `SELECT id, env, started_at AS startedAt, finished_at AS finishedAt, outcome, detail
+                 FROM runs WHERE env = ?1 ORDER BY id DESC LIMIT ?2`,
+              )
+              .all(env, limit) as ReadonlyArray<RunRecord>
+          }),
+
         acquireLock: (name, ttlMs) =>
           Clock.currentTimeMillis.pipe(
             Effect.flatMap((nowMs) =>

package/src/state/store.ts

@@ -10,9 +10,10 @@ export class StateError extends Data.TaggedError("StateError")<{
  * на неё; стор со схемой старше (в т.ч. созданный до появления версии)
  * открытие не проходит — данные догоняет явный `efmesh migrate`.
  * 1 — базовая раскладка (F4), 2 — applied_by в журнале планов (F5),
- * 3 — fingerprint_version в снапшотах (F6).
+ * 3 — fingerprint_version в снапшотах (F6), 4 — журнал тиков run (0.2.0),
+ * 5 — кэш канонизации canon_cache (0.2.0, #8).
  */
-export const STATE_VERSION = 3
+export const STATE_VERSION = 5
 
 /** Схема стора не совпадает с ожидаемой бинарём — нужен `efmesh migrate`. */
 export class StateSchemaError extends Data.TaggedError("StateSchemaError")<{
@@ -75,6 +76,22 @@ export interface PlanRecord {
   readonly appliedBy: string
 }
 
+/**
+ * Запись журнала тиков run (SPEC §7, issue #2): упавший в три часа ночи
+ * cron-тик должен быть дебажим задним числом. outcome:
+ * ok — тик прошёл; awaiting-human — есть неприменённые изменения (exit 2);
+ * lock-held — окружение занято другим процессом; error — настоящий сбой.
+ */
+export interface RunRecord {
+  readonly id: number
+  readonly env: string
+  readonly startedAt: string
+  readonly finishedAt: string
+  readonly outcome: "ok" | "awaiting-human" | "lock-held" | "error"
+  /** ok: JSON-массив собранных моделей; awaiting-human: список изменений; error: тег ошибки. */
+  readonly detail: string
+}
+
 /**
  * Учёт заполненных интервалов снапшота (SPEC §6) — единственный источник
  * правды о том, что посчитано: физическая таблица без записей здесь
@@ -137,6 +154,20 @@ export interface StateStoreShape {
     summary: string,
     appliedBy: string,
   ) => Effect.Effect<void, StateError>
+  /**
+   * Кэш канонизации (#8): ключ уже включает диалект и FINGERPRINT_VERSION —
+   * смена алгоритма или движка не может отдать протухший канон. Кэш — не
+   * данные: промах или сбой безопасны, вызывающий обязан их глотать.
+   */
+  readonly getCanon: (key: string) => Effect.Effect<string | undefined, StateError>
+  readonly putCanon: (key: string, canonical: string) => Effect.Effect<void, StateError>
+  /** Журнал тиков run (SPEC §7): исход каждого тика, включая неуспешные. */
+  readonly recordRun: (record: Omit<RunRecord, "id">) => Effect.Effect<void, StateError>
+  /** Последние тики окружения, свежие первыми. */
+  readonly listRuns: (
+    env: string,
+    limit: number,
+  ) => Effect.Effect<ReadonlyArray<RunRecord>, StateError>
   readonly listPlans: (env: string) => Effect.Effect<ReadonlyArray<PlanRecord>, StateError>
   /**
    * Межпроцессная блокировка (SPEC §7): true — получена, false — держит