@effectstream/db 0.100.0

package/assets-config.json

@@ -0,0 +1,28 @@
+{
+	"files": [
+		{
+			"importPath": "./migrations/system-up-v-0.0.0.sql",
+			"calledName": "system-up-v-0-0-0"
+		},
+		{
+			"importPath": "./migrations/system-up-v-0.0.1.sql",
+			"calledName": "system-up-v-0-0-1"
+		},
+		{
+			"importPath": "./migrations/system-up-v-0.0.2.sql",
+			"calledName": "system-up-v-0-0-2"
+		},
+		{
+			"importPath": "./migrations/system-up-v-0.8.1.sql",
+			"calledName": "system-up-v-0-8-1"
+		},
+		{
+			"importPath": "./migrations/system-down-v-0.0.0.sql",
+			"calledName": "system-down-v-0-0-0"
+		},
+		{
+			"importPath": "./migrations/system-down-v-0.0.1.sql",
+			"calledName": "system-down-v-0-0-1"
+		}
+	]
+}

package/migrations/assets.ts

@@ -0,0 +1,35 @@
+
+  function decodeBase64(b64: string): Uint8Array {
+    return Uint8Array.from(atob(b64), c => c.charCodeAt(0));
+  }
+  
+  const bundledObject = {
+    files:{
+      "system-up-v-0-0-0":{
+      content:decodeBase64("Q1JFQVRFIFNDSEVNQSBJRiBOT1QgRVhJU1RTIGVmZmVjdHN0cmVhbTsKCkNSRUFURSBFWFRFTlNJT04gSUYgTk9UIEVYSVNUUyBwZ19pdm07CgpDUkVBVEUgVEFCTEUgZWZmZWN0c3RyZWFtLmVmZmVjdHN0cmVhbV9leHBlY3RlZF92ZXJzaW9uICgKICBhcHBfdmVyc2lvbl9tYWpvciBJTlRFR0VSIE5PVCBOVUxMLAogIGFwcF92ZXJzaW9uX21pbm9yIElOVEVHRVIgTk9UIE5VTEwsCiAgYXBwX3ZlcnNpb25fcGF0Y2ggSU5URUdFUiBOT1QgTlVMTCwKICBlbmdpbmVfdmVyc2lvbl9tYWpvciBJTlRFR0VSIE5PVCBOVUxMLAogIGVuZ2luZV92ZXJzaW9uX21pbm9yIElOVEVHRVIgTk9UIE5VTEwsCiAgZW5naW5lX3ZlcnNpb25fcGF0Y2ggSU5URUdFUiBOT1QgTlVMTCwKICBibG9ja19oZWlnaHQgSU5URUdFUiBOT1QgTlVMTAopOwoKQ1JFQVRFIFVOSVFVRSBJTkRFWCBlZmZlY3RzdHJlYW1fZXhwZWN0ZWRfdmVyc2lvbl91bmlxdWVfdmVyc2lvbl9ibG9ja19oZWlnaHQgCk9OIGVmZmVjdHN0cmVhbS5lZmZlY3RzdHJlYW1fZXhwZWN0ZWRfdmVyc2lvbiAKKGFwcF92ZXJzaW9uX21ham9yLCBhcHBfdmVyc2lvbl9taW5vciwgYXBwX3ZlcnNpb25fcGF0Y2gsIAplbmdpbmVfdmVyc2lvbl9tYWpvciwgZW5naW5lX3ZlcnNpb25fbWlub3IsIGVuZ2luZV92ZXJzaW9uX3BhdGNoKTsKCkNSRUFURSBUQUJMRSBlZmZlY3RzdHJlYW0uZWZmZWN0c3RyZWFtX3ZlcnNpb25faGlzdG9yeSAoCiAgYXBwX3ZlcnNpb25fbWFqb3IgSU5URUdFUiBOT1QgTlVMTCwKICBhcHBfdmVyc2lvbl9taW5vciBJTlRFR0VSIE5PVCBOVUxMLAogIGFwcF92ZXJzaW9uX3BhdGNoIElOVEVHRVIgTk9UIE5VTEwsCiAgZW5naW5lX3ZlcnNpb25fbWFqb3IgSU5URUdFUiBOT1QgTlVMTCwKICBlbmdpbmVfdmVyc2lvbl9taW5vciBJTlRFR0VSIE5PVCBOVUxMLAogIGVuZ2luZV92ZXJzaW9uX3BhdGNoIElOVEVHRVIgTk9UIE5VTEwsCiAgYmxvY2tfaGVpZ2h0IElOVEVHRVIgTk9UIE5VTEwKKTsKCkNSRUFURSBVTklRVUUgSU5ERVggZWZmZWN0c3RyZWFtX3ZlcnNpb25faGlzdG9yeV91bmlxdWVfdmVyc2lvbl9ibG9ja19oZWlnaHQgCk9OIGVmZmVjdHN0cmVhbS5lZmZlY3RzdHJlYW1fdmVyc2lvbl9oaXN0b3J5IAooYXBwX3ZlcnNpb25fbWFqb3IsIGFwcF92ZXJzaW9uX21pbm9yLCBhcHBfdmVyc2lvbl9wYXRjaCwgCmVuZ2luZV92ZXJzaW9uX21ham9yLCBlbmdpbmVfdmVyc2lvbl9taW5vciwgZW5naW5lX3ZlcnNpb25fcGF0Y2gpOwoKQ1JFQVRFIFRBQkxFIGVmZmVjdHN0cmVhbS5lZmZlY3RzdHJlYW1fbWlncmF0aW9uX2hpc3RvcnkgKAogIG5hbWUgVEVYVCBOT1QgTlVMTCwKICBibG9ja19oZWlnaHQgSU5URUdFUiBOT1QgTlVMTCwKICBpc19zeXN0ZW1fbWlncmF0aW9uIEJPT0xFQU4gTk9UIE5VTEwKKTsKCg=="),
+      extension: "sql"
+    },
+    "system-up-v-0-0-1":{
+      content:decodeBase64("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"),
+      extension: "sql"
+    },
+    "system-up-v-0-0-2":{
+      content:decodeBase64("LS0gRW5mb3JjZSB1bmlxdWVuZXNzIGZvciBtaWdyYXRpb24gaGlzdG9yeSBlbnRyaWVzCkNSRUFURSBVTklRVUUgSU5ERVggSUYgTk9UIEVYSVNUUyBlZmZlY3RzdHJlYW1fbWlncmF0aW9uX2hpc3RvcnlfdW5pcXVlX25hbWVfc3lzdGVtCk9OIGVmZmVjdHN0cmVhbS5lZmZlY3RzdHJlYW1fbWlncmF0aW9uX2hpc3RvcnkgKG5hbWUsIGlzX3N5c3RlbV9taWdyYXRpb24pOwoKLS0gQWRkIGlkZW1wb3RlbmN5IHN1cHBvcnQgZm9yIHByaW1pdGl2ZSBhY2NvdW50aW5nIGVudHJpZXMKRE8gJCQKQkVHSU4KICBJRiBOT1QgRVhJU1RTICgKICAgIFNFTEVDVCAxCiAgICBGUk9NIGluZm9ybWF0aW9uX3NjaGVtYS5jb2x1bW5zCiAgICBXSEVSRSB0YWJsZV9zY2hlbWEgPSAnZWZmZWN0c3RyZWFtJwogICAgICBBTkQgdGFibGVfbmFtZSA9ICdwcmltaXRpdmVfYWNjb3VudGluZycKICAgICAgQU5EIGNvbHVtbl9uYW1lID0gJ3BheWxvYWRfaGFzaCcKICApIFRIRU4KICAgIEFMVEVSIFRBQkxFIGVmZmVjdHN0cmVhbS5wcmltaXRpdmVfYWNjb3VudGluZwogICAgICBBREQgQ09MVU1OIHBheWxvYWRfaGFzaCBURVhUIEdFTkVSQVRFRCBBTFdBWVMgQVMgKG1kNShwYXlsb2FkOjp0ZXh0KSkgU1RPUkVEOwogIEVORCBJRjsKRU5ECiQkOwoKQ1JFQVRFIFVOSVFVRSBJTkRFWCBJRiBOT1QgRVhJU1RTIHByaW1pdGl2ZV9hY2NvdW50aW5nX3VuaXF1ZV9wYXlsb2FkX3Blcl9ibG9jawpPTiBlZmZlY3RzdHJlYW0ucHJpbWl0aXZlX2FjY291bnRpbmcgKHByaW1pdGl2ZV9uYW1lLCBlZmZlY3RzdHJlYW1fYmxvY2tfaGVpZ2h0LCBwYXlsb2FkX2hhc2gpOwo="),
+      extension: "sql"
+    },
+    "system-up-v-0-8-1":{
+      content:decodeBase64("Q1JFQVRFIFRBQkxFIGVmZmVjdHN0cmVhbS5zeW5jX3Byb3RvY29sX2NvbmZpZ19zbmFwc2hvdCAoCiAgcHJvdG9jb2xfbmFtZSBURVhUIFBSSU1BUlkgS0VZLAogIG5ldHdvcmtfdHlwZSBURVhUIE5PVCBOVUxMLAogIGltbXV0YWJsZV9jb25maWcgSlNPTkIgTk9UIE5VTEwKKTsK"),
+      extension: "sql"
+    },
+    "system-down-v-0-0-0":{
+      content:decodeBase64("RFJPUCBUQUJMRSBlZmZlY3RzdHJlYW0uZWZmZWN0c3RyZWFtX3ZlcnNpb25faGlzdG9yeTsKRFJPUCBUQUJMRSBlZmZlY3RzdHJlYW0uZWZmZWN0c3RyZWFtX21pZ3JhdGlvbl9oaXN0b3J5Ow=="),
+      extension: "sql"
+    },
+    "system-down-v-0-0-1":{
+      content:decodeBase64("RFJPUCBUQUJMRSBlZmZlY3RzdHJlYW0uZWZmZWN0c3RyZWFtX2Jsb2NrczsKRFJPUCBUQUJMRSBlZmZlY3RzdHJlYW0ucm9sbHVwX2lucHV0czsKRFJPUCBUQUJMRSBlZmZlY3RzdHJlYW0ucm9sbHVwX2lucHV0X2Z1dHVyZV9ibG9jazsKRFJPUCBUQUJMRSBlZmZlY3RzdHJlYW0ucm9sbHVwX2lucHV0X2Z1dHVyZV90aW1lc3RhbXA7CkRST1AgVEFCTEUgZWZmZWN0c3RyZWFtLnJvbGx1cF9pbnB1dF9yZXN1bHQ7CkRST1AgVEFCTEUgZWZmZWN0c3RyZWFtLnJvbGx1cF9pbnB1dF9vcmlnaW47CkRST1AgVEFCTEUgZWZmZWN0c3RyZWFtLm5vbmNlczsKRFJPUCBUQUJMRSBlZmZlY3RzdHJlYW0uc3luY19wcm90b2NvbF9wYWdpbmF0aW9uOwpEUk9QIFRBQkxFIGVmZmVjdHN0cmVhbS5wcmltaXRpdmVfY29uZmlnOwpEUk9QIFRBQkxFIGVmZmVjdHN0cmVhbS5hZGRyZXNzZXM7CkRST1AgVEFCTEUgZWZmZWN0c3RyZWFtLmRlbGVnYXRpb25zOwpEUk9QIFRBQkxFIGVmZmVjdHN0cmVhbS5hY2hpZXZlbWVudF9wcm9ncmVzczsKRFJPUCBUQUJMRSBlZmZlY3RzdHJlYW0uZXZlbnQ7CkRST1AgVEFCTEUgZWZmZWN0c3RyZWFtLnJlZ2lzdGVyZWRfZXZlbnQ7Cg=="),
+      extension: "sql"
+    }
+    }
+  } 
+  export default bundledObject;
+

package/migrations/readme.md

@@ -0,0 +1,37 @@
+# Effectstream DB Management
+
+`System Migrations` create and update the DB structure to run with specific
+versions of Effectstream.\
+All migrations are applied that are <= than the current version.
+
+> Note v0.0.0 is a special migration that gets applied once before the chain
+> sync
+
+### Migration Files
+
+Files must be named as the version where they will be applied.\
+E.g.,
+
+- system-up-v-0.3.20
+- system-up-v-1.0.0
+
+### Version
+
+Package Version is the System Version.\
+Version in root `deno.json` must be kept in sync with `system-version.ts`, as we
+cannot read this file from the executing engine.
+
+### Deno JSR
+
+At the time JSR requires to bundle assets in TS. This is automatically applied
+when the Pgtyped is called
+
+```
+deno task pgtyped:update
+```
+
+generate assets.ts from packages/node-sdk/db directory
+
+```
+rm ./migrations/assets.ts && deno run --allow-read jsr:@codemonument/asset-builder --import-file assets-config.json  >> ./migrations/assets.ts
+```

package/migrations/system-down-v-0.0.0.sql

@@ -0,0 +1,2 @@
+DROP TABLE effectstream.effectstream_version_history;
+DROP TABLE effectstream.effectstream_migration_history;

package/migrations/system-down-v-0.0.1.sql

@@ -0,0 +1,14 @@
+DROP TABLE effectstream.effectstream_blocks;
+DROP TABLE effectstream.rollup_inputs;
+DROP TABLE effectstream.rollup_input_future_block;
+DROP TABLE effectstream.rollup_input_future_timestamp;
+DROP TABLE effectstream.rollup_input_result;
+DROP TABLE effectstream.rollup_input_origin;
+DROP TABLE effectstream.nonces;
+DROP TABLE effectstream.sync_protocol_pagination;
+DROP TABLE effectstream.primitive_config;
+DROP TABLE effectstream.addresses;
+DROP TABLE effectstream.delegations;
+DROP TABLE effectstream.achievement_progress;
+DROP TABLE effectstream.event;
+DROP TABLE effectstream.registered_event;

package/migrations/system-up-v-0.0.0.sql

@@ -0,0 +1,40 @@
+CREATE SCHEMA IF NOT EXISTS effectstream;
+
+CREATE EXTENSION IF NOT EXISTS pg_ivm;
+
+CREATE TABLE effectstream.effectstream_expected_version (
+  app_version_major INTEGER NOT NULL,
+  app_version_minor INTEGER NOT NULL,
+  app_version_patch INTEGER NOT NULL,
+  engine_version_major INTEGER NOT NULL,
+  engine_version_minor INTEGER NOT NULL,
+  engine_version_patch INTEGER NOT NULL,
+  block_height INTEGER NOT NULL
+);
+
+CREATE UNIQUE INDEX effectstream_expected_version_unique_version_block_height 
+ON effectstream.effectstream_expected_version 
+(app_version_major, app_version_minor, app_version_patch, 
+engine_version_major, engine_version_minor, engine_version_patch);
+
+CREATE TABLE effectstream.effectstream_version_history (
+  app_version_major INTEGER NOT NULL,
+  app_version_minor INTEGER NOT NULL,
+  app_version_patch INTEGER NOT NULL,
+  engine_version_major INTEGER NOT NULL,
+  engine_version_minor INTEGER NOT NULL,
+  engine_version_patch INTEGER NOT NULL,
+  block_height INTEGER NOT NULL
+);
+
+CREATE UNIQUE INDEX effectstream_version_history_unique_version_block_height 
+ON effectstream.effectstream_version_history 
+(app_version_major, app_version_minor, app_version_patch, 
+engine_version_major, engine_version_minor, engine_version_patch);
+
+CREATE TABLE effectstream.effectstream_migration_history (
+  name TEXT NOT NULL,
+  block_height INTEGER NOT NULL,
+  is_system_migration BOOLEAN NOT NULL
+);
+

package/migrations/system-up-v-0.0.1.sql

@@ -0,0 +1,117 @@
+CREATE SCHEMA IF NOT EXISTS effectstream;
+CREATE SCHEMA IF NOT EXISTS primitives;
+
+CREATE TABLE effectstream.effectstream_blocks (
+  block_height INTEGER PRIMARY KEY,
+  ver INTEGER NOT NULL,
+  main_chain_block_hash BYTEA NOT NULL,
+  seed TEXT NOT NULL,
+  ms_timestamp TIMESTAMP without time zone NOT NULL,
+  effectstream_block_hash BYTEA
+);
+
+CREATE TABLE effectstream.rollup_inputs (
+  id SERIAL PRIMARY KEY,
+  from_address TEXT NOT NULL,
+  from_address_type INTEGER NOT NULL,
+  input_data TEXT NOT NULL
+);
+
+CREATE TABLE effectstream.rollup_input_future_block (
+  id INTEGER PRIMARY KEY REFERENCES effectstream.rollup_inputs(id) ON DELETE CASCADE,
+  future_block_height INTEGER NOT NULL
+);
+CREATE TABLE effectstream.rollup_input_future_timestamp (
+  id INTEGER PRIMARY KEY REFERENCES effectstream.rollup_inputs(id) ON DELETE CASCADE,
+  future_ms_timestamp TIMESTAMP without time zone NOT NULL
+);
+
+CREATE TABLE effectstream.rollup_input_result (
+  id INTEGER PRIMARY KEY REFERENCES effectstream.rollup_inputs(id) ON DELETE CASCADE,
+  success BOOLEAN NOT NULL,
+  effectstream_tx_hash BYTEA NOT NULL,
+  block_height INTEGER NOT NULL REFERENCES effectstream.effectstream_blocks(block_height),
+  index_in_block INTEGER NOT NULL
+);
+
+CREATE TABLE effectstream.rollup_input_origin (
+  id INTEGER PRIMARY KEY REFERENCES effectstream.rollup_inputs(id) ON DELETE CASCADE,
+  primitive_name TEXT,
+  caip2 TEXT,
+  tx_hash BYTEA,
+  contract_address TEXT
+);
+
+CREATE TABLE effectstream.primitive_accounting (
+  primitive_name TEXT NOT NULL,
+  id SERIAL,
+  effectstream_block_height INTEGER NOT NULL REFERENCES effectstream.effectstream_blocks(block_height),
+  payload_type TEXT NOT NULL,
+  payload JSON NOT NULL,
+  payload_hash TEXT GENERATED ALWAYS AS (md5(payload::text)) STORED,
+  PRIMARY KEY (primitive_name, id)
+);
+
+CREATE TABLE effectstream.nonces (
+  nonce TEXT PRIMARY KEY,
+  block_height INTEGER NOT NULL REFERENCES effectstream.effectstream_blocks(block_height)
+);
+
+CREATE TABLE effectstream.sync_protocol_pagination (
+  protocol_name TEXT NOT NULL,
+  page_number INTEGER NOT NULL,
+  page JSONB NOT NULL,
+  PRIMARY KEY (protocol_name, page_number)
+);
+
+CREATE INDEX sync_protocol_pagination_page_number_idx on effectstream.sync_protocol_pagination(protocol_name, page_number);
+
+CREATE TABLE effectstream.primitive_config (
+  primitive_name TEXT PRIMARY KEY,
+  primitive_type TEXT NOT NULL,
+  primitive_caip2 TEXT NOT NULL,
+  protocol_name TEXT NOT NULL,
+  config JSONB NOT NULL,
+  config_hash INTEGER NOT NULL,
+  parent_name TEXT
+);
+
+CREATE TABLE effectstream.accounts (
+  id SERIAL PRIMARY KEY,
+  primary_address TEXT
+);
+
+CREATE TABLE effectstream.addresses (
+  address TEXT NOT NULL UNIQUE,
+  address_type INTEGER NOT NULL,
+  account_id INTEGER REFERENCES effectstream.accounts(id)
+);
+
+CREATE INDEX addresses_account_id_idx ON effectstream.addresses(account_id);
+
+ALTER TABLE effectstream.accounts ADD CONSTRAINT fk_primary_address_address FOREIGN KEY (primary_address) REFERENCES effectstream.addresses(address);
+
+CREATE TABLE effectstream.achievement_progress(
+  account_id INTEGER NOT NULL REFERENCES effectstream.accounts(id),
+  name TEXT NOT NULL,
+  completed_date TIMESTAMP,
+  progress INTEGER,
+  total INTEGER,
+  PRIMARY KEY (account_id, name)
+);
+
+CREATE TABLE effectstream.event (
+  id SERIAL PRIMARY KEY,
+  topic TEXT NOT NULL,
+  address TEXT NOT NULL,
+  data JSONB NOT NULL,
+  block_height INTEGER NOT NULL,
+  tx_index INTEGER NOT NULL,
+  log_index INTEGER NOT NULL
+);
+
+CREATE TABLE effectstream.registered_event (
+  name TEXT NOT NULL,
+  topic TEXT NOT NULL,
+  PRIMARY KEY(name, topic)
+);

package/migrations/system-up-v-0.0.2.sql

@@ -0,0 +1,22 @@
+-- Enforce uniqueness for migration history entries
+CREATE UNIQUE INDEX IF NOT EXISTS effectstream_migration_history_unique_name_system
+ON effectstream.effectstream_migration_history (name, is_system_migration);
+
+-- Add idempotency support for primitive accounting entries
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1
+    FROM information_schema.columns
+    WHERE table_schema = 'effectstream'
+      AND table_name = 'primitive_accounting'
+      AND column_name = 'payload_hash'
+  ) THEN
+    ALTER TABLE effectstream.primitive_accounting
+      ADD COLUMN payload_hash TEXT GENERATED ALWAYS AS (md5(payload::text)) STORED;
+  END IF;
+END
+$$;
+
+CREATE UNIQUE INDEX IF NOT EXISTS primitive_accounting_unique_payload_per_block
+ON effectstream.primitive_accounting (primitive_name, effectstream_block_height, payload_hash);

package/migrations/system-up-v-0.8.1.sql

@@ -0,0 +1,5 @@
+CREATE TABLE effectstream.sync_protocol_config_snapshot (
+  protocol_name TEXT PRIMARY KEY,
+  network_type TEXT NOT NULL,
+  immutable_config JSONB NOT NULL
+);

package/migrations/system-version.ts

@@ -0,0 +1,147 @@
+import type { Client } from "pg";
+import type { Operation } from "effection";
+import { until } from "effection";
+import * as migrationFiles from "./assets.ts";
+import {
+  acquireDBMutex,
+  getLatestProcessedBlockHeight,
+  getLatestVersion,
+  releaseDBMutex,
+  tableExists,
+} from "@effectstream/db";
+type VERSION = `${number}.${number}.${number}`;
+type VERSION_NUMBER = [number, number, number];
+// NOTE This must match the version of the root deno.json
+export const EFFECTSTREAM_ENGINE_VERSION: VERSION = "0.8.1";
+
+export { applyMigrations } from "../scripts/apply-migrations.ts";
+
+export function parseVersion(version: VERSION): VERSION_NUMBER {
+  const parts = version.split(".").map((part) => Number(part));
+  if (parts.length !== 3 || parts.some((n) => Number.isNaN(n))) {
+    throw new Error(`Invalid version string: ${version}`);
+  }
+  const [major, minor, patch] = parts;
+  return [major, minor, patch];
+}
+
+export async function getMigrations(
+  from_version: VERSION | undefined = undefined,
+  to_version: VERSION = EFFECTSTREAM_ENGINE_VERSION,
+): Promise<{
+  version: VERSION;
+  sql: string;
+}[]> {
+  const toVersion: VERSION_NUMBER = parseVersion(to_version);
+  const fromVersion: VERSION_NUMBER | undefined = from_version
+    ? parseVersion(from_version)
+    : undefined;
+
+  const upMigrations: { version: VERSION_NUMBER; sql: string }[] = [];
+  Object.entries(migrationFiles.default.files).map(([key, value]) => {
+    const [s, type, v, major, minor, patch] = key.split("-");
+    if (s === "system" && type === "up" && v === "v") {
+      upMigrations.push({
+        version: [
+          parseInt(major, 10),
+          parseInt(minor, 10),
+          parseInt(patch, 10),
+        ],
+        sql: new TextDecoder().decode(value.content),
+      });
+    }
+  });
+
+  const filteredAndSorted = upMigrations
+    .filter((migration) => {
+      return (
+        (!fromVersion || (
+          // Return all migrations that are greater to the from version
+          migration.version[0] > fromVersion[0] ||
+          (migration.version[0] === fromVersion[0] &&
+            migration.version[1] > fromVersion[1]) ||
+          (migration.version[0] === fromVersion[0] &&
+            migration.version[1] === fromVersion[1] &&
+            migration.version[2] > fromVersion[2])
+        )) &&
+        // Return all migrations that are less or equal to the target version
+        (
+          migration.version[0] < toVersion[0] ||
+          (migration.version[0] === toVersion[0] &&
+            migration.version[1] < toVersion[1]) ||
+          (migration.version[0] === toVersion[0] &&
+            migration.version[1] === toVersion[1] &&
+            migration.version[2] <= toVersion[2])
+        )
+      );
+    })
+    .sort((a, b) => {
+      // Sort from oldest to newest
+      return (
+        a.version[0] - b.version[0] ||
+        a.version[1] - b.version[1] ||
+        a.version[2] - b.version[2]
+      );
+    });
+
+  return filteredAndSorted.map((migration) => ({
+    version: `${migration.version[0]}.${migration.version[1]}.${
+      migration.version[2]
+    }`,
+    sql: migration.sql,
+  }));
+}
+
+export type VersionInfo = {
+  engine_current_version: VERSION;
+  engine_previous_version: VERSION;
+  app_previous_version: VERSION;
+  is_empty: boolean;
+};
+
+export function* getLastBlockHeight(
+  versionInfo: VersionInfo,
+  dbConn: Client,
+): Operation<number> {
+  yield* acquireDBMutex("get-last-block-height");
+  const v = versionInfo.is_empty
+    ? 0
+    : (yield* until(getLatestProcessedBlockHeight.run(undefined, dbConn)))[0]
+      .block_height;
+  releaseDBMutex("get-last-block-height");
+  return v;
+}
+
+export function* getVersionInfo(dbConn: Client): Operation<VersionInfo> {
+  // 1. Let's check if the database is empty.
+  yield* acquireDBMutex("get-version-info");
+  const [result] = yield* until(tableExists.run(undefined, dbConn));
+  releaseDBMutex("get-version-info");
+
+  if (!result.exists) {
+    return {
+      engine_current_version: EFFECTSTREAM_ENGINE_VERSION,
+      engine_previous_version: "0.0.0",
+      app_previous_version: "0.0.0",
+      is_empty: true,
+    };
+  }
+
+  // So let's check what is the latest version from the `effectstream_version_history` table.
+  yield* acquireDBMutex("get-version-info");
+  const [latestVersion] = yield* until(getLatestVersion.run(undefined, dbConn));
+  releaseDBMutex("get-version-info");
+
+  if (!latestVersion) {
+    throw new Error("Internal error: No version found in the database");
+  }
+
+  return {
+    engine_current_version: EFFECTSTREAM_ENGINE_VERSION,
+    engine_previous_version:
+      `${latestVersion.engine_version_major}.${latestVersion.engine_version_minor}.${latestVersion.engine_version_patch}`,
+    app_previous_version:
+      `${latestVersion.app_version_major}.${latestVersion.app_version_minor}.${latestVersion.app_version_patch}`,
+    is_empty: false,
+  };
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@effectstream/db",
+  "version": "0.100.0",
+  "license": "MIT",
+  "exports": {
+    ".": "./src/mod.ts",
+    "./start-pglite": "./scripts/start-pglite.ts",
+    "./apply-migrations": "./scripts/apply-migrations.ts",
+    "./db-up": "./scripts/start-pglite.ts",
+    "./db-wait": "./scripts/wait-for-db.ts",
+    "./pgtyped-update": "./scripts/pgtyped-update.ts",
+    "./version": "./migrations/system-version.ts"
+  },
+  "dependencies": {
+    "@effectstream/coroutine": "0.100.0",
+    "@effectstream/log": "0.100.0",
+    "@effectstream/runtime": "0.100.0",
+    "@effectstream/sync": "0.100.0",
+    "@effectstream/utils": "0.100.0",
+    "@electric-sql/pglite": "^0.3.14",
+    "@pgtyped/runtime": "2.4.2",
+    "@pgtyped/parser": "2.4.2",
+    "pg": "8.17.2",
+    "pg-tx": "^1.0.1",
+    "effection": "^3.5.0",
+    "pg-gateway": "^0.3.0-beta.4"
+  },
+  "devDependencies": {
+    "@paima/pgtyped-cli": "^2.4.5",
+    "wait-on": "8.0.3",
+    "concurrently": "9.1.2"
+  }
+}

package/pgtypedconfig.json

@@ -0,0 +1,21 @@
+{
+  "transforms": [
+    {
+      "mode": "sql",
+      "include": "**/*.sql",
+      "emitTemplate": "{{dir}}/{{name}}.queries.ts"
+    }
+  ],
+  "srcDir": "./src/sql",
+  "failOnError": false,
+  "camelCaseColumnNames": false,
+  "db": {
+    "dbName": "postgres",
+    "user": "postgres",
+    "password": "postgres",
+    "host": "localhost",
+    "port": 5432,
+    "ssl": false
+  },
+  "maxWorkerThreads": 1
+}

package/scripts/Dockerfile

@@ -0,0 +1,13 @@
+FROM postgres:15.9 AS builder
+
+RUN apt-get update && apt-get -y install git postgresql-server-dev-15 build-essential && rm -rf /var/lib/apt/lists/*
+
+RUN git clone https://github.com/sraoss/pg_ivm
+WORKDIR /pg_ivm
+
+RUN git checkout v1.11
+RUN make
+RUN make DESTDIR=/pg_ivm/output install
+
+FROM postgres:15.9
+COPY --from=builder /pg_ivm/output /

package/scripts/apply-migrations.ts

@@ -0,0 +1,49 @@
+import { getConnection } from "../src/pg-connection.ts";
+import { getMigrations } from "../migrations/system-version.ts";
+import type { Client } from "pg";
+import { insertPaimaEngineMigration } from "@effectstream/db";
+
+export async function applyMigrations(
+  db: Client,
+  blockHeight: number,
+  name: string,
+  sql: string,
+  isSystemMigration: boolean,
+) {
+  console.log(
+    `[APPLY MIGRATION] Block height: ${blockHeight} | Migration: ${name}`,
+  );
+  await db.query(sql);
+  await insertPaimaEngineMigration.run(
+    {
+      name,
+      blockHeight,
+      isSystemMigration,
+    },
+    db,
+  );
+}
+
+// Functions for standalone execution
+async function standAloneApplyInitialMigrations(
+  db: any, // Client,
+  blockHeight: number,
+) {
+  const migrations = await getMigrations();
+  for (const migration of migrations) {
+    await applyMigrations(
+      db,
+      blockHeight,
+      migration.version,
+      migration.sql,
+      true,
+    );
+  }
+}
+
+if (import.meta.main) {
+  const db = await getConnection();
+  await standAloneApplyInitialMigrations(db, 0);
+  console.log("✅ System migrations applied");
+  process.exit(0);
+}

package/scripts/pgtyped-internal.ts

@@ -0,0 +1,43 @@
+#!/usr/bin/env bun
+import { spawn } from "node:child_process";
+import { waitForDb } from "./wait-for-db.ts";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+async function runPgtyped() {
+  try {
+    console.log("🔄 Running pgtyped...");
+    const __dirname = dirname(import.meta.url?.startsWith("file:") ? fileURLToPath(import.meta.url) : import.meta.url.replace("file://", ""));
+    const configPath = join(__dirname, "../pgtypedconfig.json");
+    const child = spawn("npx", ["pgtyped", "-c", configPath], {
+      stdio: "inherit",
+      shell: true,
+    });
+
+    const code = await new Promise<number | null>((resolve) => {
+      child.on("close", (code) => resolve(code));
+    });
+
+    if (code === 0) {
+      console.log("✅ pgtyped completed successfully");
+    } else {
+      console.error("❌ pgtyped failed");
+      process.exit(code ?? 1);
+    }
+  } catch (error) {
+    console.error("❌ Error running pgtyped:", error);
+    process.exit(1);
+  }
+}
+
+async function main() {
+  // First wait for the database
+  await waitForDb();
+
+  // Then run pgtyped
+  await runPgtyped();
+}
+
+if (import.meta.main) {
+  await main();
+}