@mepuka/skygent 0.2.0

package/src/cli/watch.ts

@@ -0,0 +1,344 @@
+import { Command, Options } from "@effect/cli";
+import { Effect, Layer, Option, Stream } from "effect";
+import { Jetstream } from "effect-jetstream";
+import { filterExprSignature } from "../domain/filter.js";
+import { DataSource } from "../domain/sync.js";
+import { SyncReporter } from "../services/sync-reporter.js";
+import { JetstreamSyncEngine } from "../services/jetstream-sync.js";
+import { parseFilterExpr } from "./filter-input.js";
+import { CliOutput, writeJsonStream } from "./output.js";
+import { storeOptions } from "./store.js";
+import { logInfo, makeSyncReporter } from "./logging.js";
+import { ResourceMonitor } from "../services/resource-monitor.js";
+import { withExamples } from "./help.js";
+import { buildJetstreamSelection, jetstreamOptions } from "./jetstream.js";
+import { makeWatchCommandBody } from "./sync-factory.js";
+import {
+  feedUriArg,
+  listUriArg,
+  postUriArg,
+  actorArg,
+  storeNameOption,
+  filterOption,
+  filterJsonOption,
+  postFilterOption,
+  postFilterJsonOption,
+  authorFilterOption,
+  includePinsOption,
+  decodeActor,
+  quietOption,
+  refreshOption,
+  strictOption,
+  maxErrorsOption,
+  parseMaxErrors,
+  parseBoundedIntOption
+} from "./shared-options.js";
+
+const intervalOption = Options.text("interval").pipe(
+  Options.withDescription(
+    "Polling interval (e.g. \"30 seconds\", \"500 millis\") (default: 30 seconds)"
+  ),
+  Options.optional
+);
+const depthOption = Options.integer("depth").pipe(
+  Options.withDescription("Thread reply depth to include (0-1000, default 6)"),
+  Options.optional
+);
+const parentHeightOption = Options.integer("parent-height").pipe(
+  Options.withDescription("Thread parent height to include (0-1000, default 80)"),
+  Options.optional
+);
+
+const timelineCommand = Command.make(
+  "timeline",
+  {
+    store: storeNameOption,
+    filter: filterOption,
+    filterJson: filterJsonOption,
+    interval: intervalOption,
+    quiet: quietOption,
+    refresh: refreshOption
+  },
+  makeWatchCommandBody("timeline", () => DataSource.timeline())
+).pipe(
+  Command.withDescription(
+    withExamples(
+      "Watch timeline updates and emit sync results",
+      [
+        "skygent watch timeline --store my-store",
+        "skygent watch timeline --store my-store --interval \"5 minutes\" --quiet"
+      ],
+      ["Tip: add --quiet to suppress progress logs."]
+    )
+  )
+);
+
+const feedCommand = Command.make(
+  "feed",
+  {
+    uri: feedUriArg,
+    store: storeNameOption,
+    filter: filterOption,
+    filterJson: filterJsonOption,
+    interval: intervalOption,
+    quiet: quietOption,
+    refresh: refreshOption
+  },
+  ({ uri, ...rest }) => makeWatchCommandBody("feed", () => DataSource.feed(uri), { uri })(rest)
+).pipe(
+  Command.withDescription(
+    withExamples(
+      "Watch a feed URI and emit sync results",
+      [
+        "skygent watch feed at://did:plc:example/app.bsky.feed.generator/xyz --store my-store --interval \"2 minutes\""
+      ],
+      ["Tip: add --quiet to suppress progress logs."]
+    )
+  )
+);
+
+const listCommand = Command.make(
+  "list",
+  {
+    uri: listUriArg,
+    store: storeNameOption,
+    filter: filterOption,
+    filterJson: filterJsonOption,
+    interval: intervalOption,
+    quiet: quietOption,
+    refresh: refreshOption
+  },
+  ({ uri, ...rest }) => makeWatchCommandBody("list", () => DataSource.list(uri), { uri })(rest)
+).pipe(
+  Command.withDescription(
+    withExamples(
+      "Watch a list feed URI and emit sync results",
+      [
+        "skygent watch list at://did:plc:example/app.bsky.graph.list/xyz --store my-store --interval \"2 minutes\""
+      ],
+      ["Tip: add --quiet to suppress progress logs."]
+    )
+  )
+);
+
+const notificationsCommand = Command.make(
+  "notifications",
+  {
+    store: storeNameOption,
+    filter: filterOption,
+    filterJson: filterJsonOption,
+    interval: intervalOption,
+    quiet: quietOption,
+    refresh: refreshOption
+  },
+  makeWatchCommandBody("notifications", () => DataSource.notifications())
+).pipe(
+  Command.withDescription(
+    withExamples(
+      "Watch notifications and emit sync results",
+      ["skygent watch notifications --store my-store --interval \"1 minute\" --quiet"],
+      ["Tip: add --quiet to suppress progress logs."]
+    )
+  )
+);
+
+const authorCommand = Command.make(
+  "author",
+  {
+    actor: actorArg,
+    store: storeNameOption,
+    filter: authorFilterOption,
+    includePins: includePinsOption,
+    postFilter: postFilterOption,
+    postFilterJson: postFilterJsonOption,
+    interval: intervalOption,
+    quiet: quietOption,
+    refresh: refreshOption
+  },
+  ({ actor, filter, includePins, postFilter, postFilterJson, interval, store, quiet, refresh }) =>
+    Effect.gen(function* () {
+      const resolvedActor = yield* decodeActor(actor);
+      const apiFilter = Option.getOrUndefined(filter);
+      const source = DataSource.author(resolvedActor, {
+        ...(apiFilter !== undefined ? { filter: apiFilter } : {}),
+        ...(includePins ? { includePins: true } : {})
+      });
+      const run = makeWatchCommandBody("author", () => source, {
+        actor: resolvedActor,
+        ...(apiFilter !== undefined ? { filter: apiFilter } : {}),
+        ...(includePins ? { includePins: true } : {})
+      });
+      return yield* run({
+        store,
+        filter: postFilter,
+        filterJson: postFilterJson,
+        interval,
+        quiet,
+        refresh
+      });
+    })
+).pipe(
+  Command.withDescription(
+    withExamples(
+      "Watch an author's feed and emit sync results",
+      [
+        "skygent watch author alice.bsky.social --store my-store",
+        "skygent watch author did:plc:example --store my-store --filter posts_no_replies --include-pins"
+      ],
+      ["Tip: use --post-filter to apply the DSL filter to synced posts."]
+    )
+  )
+);
+
+const threadCommand = Command.make(
+  "thread",
+  {
+    uri: postUriArg,
+    store: storeNameOption,
+    depth: depthOption,
+    parentHeight: parentHeightOption,
+    filter: filterOption,
+    filterJson: filterJsonOption,
+    interval: intervalOption,
+    quiet: quietOption,
+    refresh: refreshOption
+  },
+  ({ uri, depth, parentHeight, filter, filterJson, interval, store, quiet, refresh }) =>
+    Effect.gen(function* () {
+      const parsedDepth = yield* parseBoundedIntOption(depth, "depth", 0, 1000);
+      const parsedParentHeight = yield* parseBoundedIntOption(
+        parentHeight,
+        "parent-height",
+        0,
+        1000
+      );
+      const depthValue = Option.getOrUndefined(parsedDepth);
+      const parentHeightValue = Option.getOrUndefined(parsedParentHeight);
+      const source = DataSource.thread(uri, {
+        ...(depthValue !== undefined ? { depth: depthValue } : {}),
+        ...(parentHeightValue !== undefined ? { parentHeight: parentHeightValue } : {})
+      });
+      const run = makeWatchCommandBody("thread", () => source, {
+        uri,
+        ...(depthValue !== undefined ? { depth: depthValue } : {}),
+        ...(parentHeightValue !== undefined ? { parentHeight: parentHeightValue } : {})
+      });
+      return yield* run({ store, filter, filterJson, interval, quiet, refresh });
+    })
+).pipe(
+  Command.withDescription(
+    withExamples(
+      "Watch a thread and emit sync results",
+      [
+        "skygent watch thread at://did:plc:example/app.bsky.feed.post/xyz --store my-store",
+        "skygent watch thread at://did:plc:example/app.bsky.feed.post/xyz --store my-store --depth 10 --parent-height 5"
+      ],
+      ["Tip: use --filter to apply the DSL filter to thread posts."]
+    )
+  )
+);
+
+const jetstreamCommand = Command.make(
+  "jetstream",
+  {
+    store: storeNameOption,
+    filter: filterOption,
+    filterJson: filterJsonOption,
+    quiet: quietOption,
+    endpoint: jetstreamOptions.endpoint,
+    collections: jetstreamOptions.collections,
+    dids: jetstreamOptions.dids,
+    cursor: jetstreamOptions.cursor,
+    compress: jetstreamOptions.compress,
+    maxMessageSize: jetstreamOptions.maxMessageSize,
+    strict: strictOption,
+    maxErrors: maxErrorsOption
+  },
+  ({
+    store,
+    filter,
+    filterJson,
+    quiet,
+    endpoint,
+    collections,
+    dids,
+    cursor,
+    compress,
+    maxMessageSize,
+    strict,
+    maxErrors
+  }) =>
+    Effect.gen(function* () {
+      const monitor = yield* ResourceMonitor;
+      const output = yield* CliOutput;
+      const storeRef = yield* storeOptions.loadStoreRef(store);
+      const expr = yield* parseFilterExpr(filter, filterJson);
+      const filterHash = filterExprSignature(expr);
+      const selection = yield* buildJetstreamSelection(
+        {
+          endpoint,
+          collections,
+          dids,
+          cursor,
+          compress,
+          maxMessageSize
+        },
+        storeRef,
+        filterHash
+      );
+      const parsedMaxErrors = yield* parseMaxErrors(maxErrors);
+      const engineLayer = JetstreamSyncEngine.layer.pipe(
+        Layer.provideMerge(Jetstream.live(selection.config))
+      );
+      yield* logInfo("Starting watch", { source: "jetstream", store: storeRef.name });
+      yield* Effect.gen(function* () {
+        const engine = yield* JetstreamSyncEngine;
+        const maxErrorsValue = Option.getOrUndefined(parsedMaxErrors);
+        const stream = engine.watch({
+          source: selection.source,
+          store: storeRef,
+          filter: expr,
+          command: "watch jetstream",
+          ...(selection.cursor !== undefined ? { cursor: selection.cursor } : {}),
+          ...(strict ? { strict } : {}),
+          ...(maxErrorsValue !== undefined ? { maxErrors: maxErrorsValue } : {})
+        });
+        const outputStream = stream.pipe(
+          Stream.map((event) => event.result),
+          Stream.provideService(
+            SyncReporter,
+            makeSyncReporter(quiet, monitor, output)
+          )
+        );
+        return yield* writeJsonStream(outputStream);
+      }).pipe(Effect.provide(engineLayer));
+    })
+).pipe(
+  Command.withDescription(
+    withExamples(
+      "Watch Jetstream updates and emit sync results (posts only)",
+      [
+        "skygent watch jetstream --store my-store",
+        "skygent watch jetstream --store my-store --quiet"
+      ],
+      ["Tip: use --collections to override subscribed collections."]
+    )
+  )
+);
+
+export const watchCommand = Command.make("watch", {}).pipe(
+  Command.withSubcommands([
+    timelineCommand,
+    feedCommand,
+    listCommand,
+    notificationsCommand,
+    authorCommand,
+    threadCommand,
+    jetstreamCommand
+  ]),
+  Command.withDescription(
+    withExamples("Continuously sync and emit results", [
+      "skygent watch timeline --store my-store --interval \"2 minutes\""
+    ])
+  )
+);

package/src/db/migrations/store-catalog/001_init.ts

@@ -0,0 +1,14 @@
+import * as SqlClient from "@effect/sql/SqlClient";
+import { Effect } from "effect";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`CREATE TABLE IF NOT EXISTS stores (
+    name TEXT PRIMARY KEY,
+    root TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    config_json TEXT NOT NULL
+  )`;
+});

package/src/db/migrations/store-index/001_init.ts

@@ -0,0 +1,34 @@
+import * as SqlClient from "@effect/sql/SqlClient";
+import { Effect } from "effect";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`CREATE TABLE IF NOT EXISTS posts (
+    uri TEXT PRIMARY KEY,
+    created_at TEXT NOT NULL,
+    created_date TEXT NOT NULL,
+    author TEXT,
+    post_json TEXT NOT NULL
+  )`;
+
+  yield* sql`CREATE TABLE IF NOT EXISTS post_hashtag (
+    uri TEXT NOT NULL,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (uri, tag),
+    FOREIGN KEY (uri) REFERENCES posts(uri) ON DELETE CASCADE
+  )`;
+
+  yield* sql`CREATE TABLE IF NOT EXISTS index_checkpoints (
+    index_name TEXT PRIMARY KEY,
+    version INTEGER NOT NULL,
+    last_event_id TEXT NOT NULL,
+    event_count INTEGER NOT NULL,
+    updated_at TEXT NOT NULL
+  )`;
+
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_created_date_idx ON posts(created_date)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_created_at_idx ON posts(created_at)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_author_idx ON posts(author)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS post_hashtag_tag_idx ON post_hashtag(tag)`;
+});

package/src/db/migrations/store-index/002_event_log.ts

@@ -0,0 +1,24 @@
+import * as SqlClient from "@effect/sql/SqlClient";
+import { Effect } from "effect";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`CREATE TABLE IF NOT EXISTS event_log (
+    event_id TEXT PRIMARY KEY,
+    event_type TEXT NOT NULL,
+    post_uri TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    source TEXT NOT NULL
+  )`;
+
+  yield* sql`CREATE TABLE IF NOT EXISTS event_log_meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+  )`;
+
+  yield* sql`CREATE INDEX IF NOT EXISTS event_log_created_at_idx ON event_log(created_at)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS event_log_post_uri_idx ON event_log(post_uri)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS event_log_source_idx ON event_log(source)`;
+});

package/src/db/migrations/store-index/003_fts_and_derived.ts

@@ -0,0 +1,52 @@
+import * as SqlClient from "@effect/sql/SqlClient";
+import { Effect } from "effect";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`ALTER TABLE posts ADD COLUMN text TEXT NOT NULL DEFAULT ''`;
+  yield* sql`ALTER TABLE posts ADD COLUMN lang TEXT`;
+  yield* sql`ALTER TABLE posts ADD COLUMN is_reply INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN is_quote INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN is_repost INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN is_original INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN has_links INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN has_media INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN has_images INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN has_video INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN like_count INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN repost_count INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`ALTER TABLE posts ADD COLUMN reply_count INTEGER NOT NULL DEFAULT 0`;
+
+  yield* sql`CREATE VIRTUAL TABLE IF NOT EXISTS posts_fts USING fts5(
+    text,
+    content='posts',
+    content_rowid='rowid'
+  )`;
+
+  yield* sql`CREATE TRIGGER IF NOT EXISTS posts_ai AFTER INSERT ON posts BEGIN
+    INSERT INTO posts_fts(rowid, text) VALUES (new.rowid, new.text);
+  END`;
+
+  yield* sql`CREATE TRIGGER IF NOT EXISTS posts_ad AFTER DELETE ON posts BEGIN
+    INSERT INTO posts_fts(posts_fts, rowid, text) VALUES ('delete', old.rowid, old.text);
+  END`;
+
+  yield* sql`CREATE TRIGGER IF NOT EXISTS posts_au AFTER UPDATE ON posts BEGIN
+    INSERT INTO posts_fts(posts_fts, rowid, text) VALUES ('delete', old.rowid, old.text);
+    INSERT INTO posts_fts(rowid, text) VALUES (new.rowid, new.text);
+  END`;
+
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_lang_idx ON posts(lang)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_is_reply_idx ON posts(is_reply)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_is_quote_idx ON posts(is_quote)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_is_repost_idx ON posts(is_repost)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_is_original_idx ON posts(is_original)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_has_links_idx ON posts(has_links)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_has_media_idx ON posts(has_media)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_has_images_idx ON posts(has_images)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_has_video_idx ON posts(has_video)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_like_count_idx ON posts(like_count)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_repost_count_idx ON posts(repost_count)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_reply_count_idx ON posts(reply_count)`;
+});

package/src/db/migrations/store-index/004_query_indexes.ts

@@ -0,0 +1,9 @@
+import * as SqlClient from "@effect/sql/SqlClient";
+import { Effect } from "effect";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_author_created_at_idx ON posts(author, created_at)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_created_at_uri_idx ON posts(created_at, uri)`;
+});

package/src/db/migrations/store-index/005_post_lang.ts

@@ -0,0 +1,15 @@
+import * as SqlClient from "@effect/sql/SqlClient";
+import { Effect } from "effect";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`CREATE TABLE IF NOT EXISTS post_lang (
+    uri TEXT NOT NULL,
+    lang TEXT NOT NULL,
+    PRIMARY KEY (uri, lang),
+    FOREIGN KEY (uri) REFERENCES posts(uri) ON DELETE CASCADE
+  )`;
+
+  yield* sql`CREATE INDEX IF NOT EXISTS post_lang_lang_uri_idx ON post_lang(lang, uri)`;
+});

package/src/db/migrations/store-index/006_has_embed.ts

@@ -0,0 +1,10 @@
+import * as SqlClient from "@effect/sql/SqlClient";
+import { Effect } from "effect";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`ALTER TABLE posts ADD COLUMN has_embed INTEGER NOT NULL DEFAULT 0`;
+  yield* sql`UPDATE posts SET has_embed = CASE WHEN has_media = 1 OR is_quote = 1 THEN 1 ELSE 0 END`;
+  yield* sql`CREATE INDEX IF NOT EXISTS posts_has_embed_idx ON posts(has_embed)`;
+});

package/src/db/migrations/store-index/007_event_seq_and_checkpoints.ts

@@ -0,0 +1,68 @@
+import * as SqlClient from "@effect/sql/SqlClient";
+import { Effect } from "effect";
+
+export default Effect.gen(function* () {
+  const sql = yield* SqlClient.SqlClient;
+
+  yield* sql`DROP TABLE IF EXISTS event_log_new`;
+  yield* sql`CREATE TABLE IF NOT EXISTS event_log_new (
+    event_seq INTEGER PRIMARY KEY AUTOINCREMENT,
+    event_id TEXT NOT NULL UNIQUE,
+    event_type TEXT NOT NULL,
+    post_uri TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    source TEXT NOT NULL
+  )`;
+  yield* sql`INSERT INTO event_log_new (event_seq, event_id, event_type, post_uri, payload_json, created_at, source)
+    SELECT rowid, event_id, event_type, post_uri, payload_json, created_at, source
+    FROM event_log
+    ORDER BY rowid`;
+  yield* sql`DROP TABLE event_log`;
+  yield* sql`ALTER TABLE event_log_new RENAME TO event_log`;
+  yield* sql`CREATE INDEX IF NOT EXISTS event_log_created_at_idx ON event_log(created_at)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS event_log_post_uri_idx ON event_log(post_uri)`;
+  yield* sql`CREATE INDEX IF NOT EXISTS event_log_source_idx ON event_log(source)`;
+
+  yield* sql`ALTER TABLE index_checkpoints RENAME TO index_checkpoints_old`;
+  yield* sql`CREATE TABLE IF NOT EXISTS index_checkpoints (
+    index_name TEXT PRIMARY KEY,
+    version INTEGER NOT NULL,
+    last_event_seq INTEGER NOT NULL,
+    event_count INTEGER NOT NULL,
+    updated_at TEXT NOT NULL
+  )`;
+  yield* sql`INSERT INTO index_checkpoints (index_name, version, last_event_seq, event_count, updated_at)
+    SELECT index_name,
+      version,
+      COALESCE((SELECT event_seq FROM event_log WHERE event_id = index_checkpoints_old.last_event_id), 0),
+      event_count,
+      updated_at
+    FROM index_checkpoints_old`;
+  yield* sql`DROP TABLE index_checkpoints_old`;
+
+  yield* sql`CREATE TABLE IF NOT EXISTS sync_checkpoints (
+    source_key TEXT PRIMARY KEY,
+    source_json TEXT NOT NULL,
+    cursor TEXT,
+    last_event_seq INTEGER,
+    filter_hash TEXT,
+    updated_at TEXT NOT NULL
+  )`;
+  yield* sql`CREATE INDEX IF NOT EXISTS sync_checkpoints_updated_at_idx ON sync_checkpoints(updated_at)`;
+
+  yield* sql`CREATE TABLE IF NOT EXISTS derivation_checkpoints (
+    view_name TEXT NOT NULL,
+    source_store TEXT NOT NULL,
+    target_store TEXT NOT NULL,
+    filter_hash TEXT NOT NULL,
+    evaluation_mode TEXT NOT NULL,
+    last_source_event_seq INTEGER,
+    events_processed INTEGER NOT NULL,
+    events_matched INTEGER NOT NULL,
+    deletes_propagated INTEGER NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (view_name, source_store)
+  )`;
+  yield* sql`CREATE INDEX IF NOT EXISTS derivation_checkpoints_updated_at_idx ON derivation_checkpoints(updated_at)`;
+});