Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company đŸ‘‡
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
feat(persistence): SQLite adapter with credentials/versions/rotations/audit repos
CarterPerez-dev58e12941e9a8
diff --git a/PROJECTS/intermediate/credential-rotation-enforcer/spec/unit/persistence/sqlite/sqlite_persistence_spec.cr b/PROJECTS/intermediate/credential-rotation-enforcer/spec/unit/persistence/sqlite/sqlite_persistence_spec.crnew file mode 100644index 00000000..9ffb07bd--- /dev/null+++ b/PROJECTS/intermediate/credential-rotation-enforcer/spec/unit/persistence/sqlite/sqlite_persistence_spec.cr@@ -0,0 +1,209 @@+# ===================+# ©AngelaMos | 2026+# sqlite_persistence_spec.cr+# ===================++require "../../../spec_helper"+require "../../../../src/cre/persistence/sqlite/sqlite_persistence"++describe CRE::Persistence::Sqlite::SqlitePersistence do+ describe "credentials repo" do+ it "round-trips a credential" do+ persist = CRE::Persistence::Sqlite::SqlitePersistence.new(":memory:")+ persist.migrate!++ c = CRE::Domain::Credential.new(+ id: UUID.random,+ external_id: "ext-1",+ kind: CRE::Domain::CredentialKind::EnvFile,+ name: "test",+ tags: {"env" => "dev"} of String => String,+ )++ persist.credentials.insert(c)+ found = persist.credentials.find(c.id).not_nil!++ found.name.should eq "test"+ found.tag("env").should eq "dev"+ found.kind.env_file?.should be_true+ ensure+ persist.try(&.close)+ end++ it "find_by_external returns the right credential" do+ persist = CRE::Persistence::Sqlite::SqlitePersistence.new(":memory:")+ persist.migrate!++ c = CRE::Domain::Credential.new(+ id: UUID.random, external_id: "uniq-x",+ kind: CRE::Domain::CredentialKind::GithubPat,+ name: "n", tags: {} of String => String,+ )+ persist.credentials.insert(c)++ found = persist.credentials.find_by_external(+ CRE::Domain::CredentialKind::GithubPat, "uniq-x",+ ).not_nil!+ found.id.should eq c.id+ ensure+ persist.try(&.close)+ end++ it "all returns every credential" do+ persist = CRE::Persistence::Sqlite::SqlitePersistence.new(":memory:")+ persist.migrate!+ 3.times do |i|+ persist.credentials.insert(+ CRE::Domain::Credential.new(+ id: UUID.random, external_id: "e#{i}",+ kind: CRE::Domain::CredentialKind::EnvFile,+ name: "n#{i}", tags: {} of String => String,+ )+ )+ end+ persist.credentials.all.size.should eq 3+ ensure+ persist.try(&.close)+ end++ it "update mutates name and tags" do+ persist = CRE::Persistence::Sqlite::SqlitePersistence.new(":memory:")+ persist.migrate!+ id = UUID.random+ persist.credentials.insert(+ CRE::Domain::Credential.new(+ id: id, external_id: "e", kind: CRE::Domain::CredentialKind::EnvFile,+ name: "before", tags: {} of String => String,+ )+ )+ persist.credentials.update(+ CRE::Domain::Credential.new(+ id: id, external_id: "e", kind: CRE::Domain::CredentialKind::EnvFile,+ name: "after", tags: {"k" => "v"} of String => String,+ )+ )+ found = persist.credentials.find(id).not_nil!+ found.name.should eq "after"+ found.tag("k").should eq "v"+ ensure+ persist.try(&.close)+ end+ end++ describe "versions repo" do+ it "round-trips a credential version with bytes" do+ persist = CRE::Persistence::Sqlite::SqlitePersistence.new(":memory:")+ persist.migrate!++ cred = CRE::Domain::Credential.new(+ id: UUID.random, external_id: "v-test",+ kind: CRE::Domain::CredentialKind::EnvFile,+ name: "v", tags: {} of String => String,+ )+ persist.credentials.insert(cred)++ v = CRE::Domain::CredentialVersion.new(+ id: UUID.random,+ credential_id: cred.id,+ ciphertext: Bytes[1, 2, 3, 4],+ dek_wrapped: Bytes[9, 8, 7],+ kek_version: 1,+ algorithm_id: 1_i16,+ )+ persist.versions.insert(v)++ found = persist.versions.find(v.id).not_nil!+ found.ciphertext.should eq Bytes[1, 2, 3, 4]+ found.dek_wrapped.should eq Bytes[9, 8, 7]+ found.algorithm_id.should eq 1_i16+ ensure+ persist.try(&.close)+ end++ it "revoke marks revoked_at" do+ persist = CRE::Persistence::Sqlite::SqlitePersistence.new(":memory:")+ persist.migrate!+ cred = CRE::Domain::Credential.new(+ id: UUID.random, external_id: "rev",+ kind: CRE::Domain::CredentialKind::EnvFile,+ name: "n", tags: {} of String => String,+ )+ persist.credentials.insert(cred)+ v = CRE::Domain::CredentialVersion.new(+ id: UUID.random, credential_id: cred.id,+ ciphertext: Bytes.new(0), dek_wrapped: Bytes.new(0),+ kek_version: 1, algorithm_id: 1_i16,+ )+ persist.versions.insert(v)+ persist.versions.revoke(v.id)++ found = persist.versions.find(v.id).not_nil!+ found.revoked?.should be_true+ ensure+ persist.try(&.close)+ end+ end++ describe "rotations repo" do+ it "tracks state transitions and in_flight filtering" do+ persist = CRE::Persistence::Sqlite::SqlitePersistence.new(":memory:")+ persist.migrate!+ cred_id = UUID.random+ persist.credentials.insert(+ CRE::Domain::Credential.new(+ id: cred_id, external_id: "rot", kind: CRE::Domain::CredentialKind::EnvFile,+ name: "n", tags: {} of String => String,+ )+ )++ r1 = CRE::Persistence::RotationRecord.new(+ id: UUID.random, credential_id: cred_id,+ rotator_kind: :env_file, state: :generating,+ started_at: Time.utc, completed_at: nil, failure_reason: nil,+ )+ r2 = CRE::Persistence::RotationRecord.new(+ id: UUID.random, credential_id: cred_id,+ rotator_kind: :env_file, state: :completed,+ started_at: Time.utc, completed_at: Time.utc, failure_reason: nil,+ )+ persist.rotations.insert(r1)+ persist.rotations.insert(r2)++ persist.rotations.in_flight.size.should eq 1+ persist.rotations.update_state(r1.id, :completed)+ persist.rotations.in_flight.size.should eq 0+ ensure+ persist.try(&.close)+ end+ end++ describe "audit repo" do+ it "appends and reads back entries; latest_hash returns genesis when empty" do+ persist = CRE::Persistence::Sqlite::SqlitePersistence.new(":memory:")+ persist.migrate!++ persist.audit.latest_hash.should eq CRE::Persistence::Sqlite::AuditRepo::GENESIS_HASH+ persist.audit.latest_seq.should eq 0_i64++ entry = CRE::Persistence::AuditEntry.new(+ seq: 0_i64, event_id: UUID.random,+ occurred_at: Time.utc, event_type: "test",+ actor: "system", target_id: nil,+ payload: %({"k":"v"}),+ prev_hash: Bytes.new(32, 0_u8),+ content_hash: Bytes.new(32, 0xaa_u8),+ hmac: Bytes.new(32, 0xbb_u8),+ hmac_key_version: 1,+ )+ persist.audit.append(entry)++ persist.audit.latest_seq.should eq 1_i64+ persist.audit.latest_hash.should eq Bytes.new(32, 0xaa_u8)+ rng = persist.audit.range(1_i64, 1_i64)+ rng.size.should eq 1+ rng[0].event_type.should eq "test"+ ensure+ persist.try(&.close)+ end+ end+enddiff --git a/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/repos.cr b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/repos.crindex c924c67f..016753b2 100644--- a/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/repos.cr+++ b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/repos.cr@@ -8,11 +8,32 @@ require "../domain/credential"require "../domain/credential_version"module CRE::Persistence+ enum RotatorKind+ AwsSecretsmgr+ VaultDynamic+ GithubPat+ EnvFile+ end++ enum RotationState+ Pending+ Generating+ Applying+ Verifying+ Committing+ Completed+ Failed+ Aborted+ Inconsistent+ end++ TERMINAL_STATES = [RotationState::Completed, RotationState::Failed, RotationState::Aborted]+record RotationRecord,id : UUID,credential_id : UUID,- rotator_kind : Symbol,- state : Symbol,+ rotator_kind : RotatorKind,+ state : RotationState,started_at : Time,completed_at : Time?,failure_reason : String?@@ -57,7 +78,7 @@ module CRE::Persistenceabstract class RotationsRepoabstract def insert(rotation : RotationRecord) : Nil- abstract def update_state(id : UUID, state : Symbol, error : String? = nil) : Nil+ abstract def update_state(id : UUID, state : RotationState, error : String? = nil) : Nilabstract def in_flight : Array(RotationRecord)enddiff --git a/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/audit_repo.cr b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/audit_repo.crnew file mode 100644index 00000000..c2d38041--- /dev/null+++ b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/audit_repo.cr@@ -0,0 +1,86 @@+# ===================+# ©AngelaMos | 2026+# audit_repo.cr+# ===================++require "db"+require "uuid"+require "../repos"++module CRE::Persistence::Sqlite+ class AuditRepo < CRE::Persistence::AuditRepo+ GENESIS_HASH = Bytes.new(32, 0_u8)++ def initialize(@db : DB::Database)+ end++ def append(entry : AuditEntry) : Nil+ @db.exec(+ "INSERT OR IGNORE INTO audit_events (event_id, occurred_at, event_type, actor, target_id, payload, prev_hash, content_hash, hmac, hmac_key_version) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",+ entry.event_id.to_s, entry.occurred_at.to_rfc3339,+ entry.event_type, entry.actor,+ entry.target_id.try(&.to_s),+ entry.payload,+ entry.prev_hash, entry.content_hash, entry.hmac,+ entry.hmac_key_version,+ )+ end++ def latest_hash : Bytes+ result = @db.query_one?(+ "SELECT content_hash FROM audit_events ORDER BY seq DESC LIMIT 1",+ as: Bytes,+ )+ result || GENESIS_HASH+ end++ def latest_seq : Int64+ result = @db.query_one?(+ "SELECT seq FROM audit_events ORDER BY seq DESC LIMIT 1",+ as: Int64,+ )+ result || 0_i64+ end++ def range(start_seq : Int64, end_seq : Int64) : Array(AuditEntry)+ @db.query_all(+ "SELECT seq, event_id, occurred_at, event_type, actor, target_id, payload, prev_hash, content_hash, hmac, hmac_key_version FROM audit_events WHERE seq >= ? AND seq <= ? ORDER BY seq ASC",+ start_seq, end_seq,+ as: {Int64, String, String, String, String, String?, String, Bytes, Bytes, Bytes, Int32},+ ).map { |row| row_to_entry(row) }+ end++ def insert_batch(batch : AuditBatch) : Nil+ @db.exec(+ "INSERT INTO audit_batches (id, start_seq, end_seq, merkle_root, signature, signing_key_version, sealed_at) VALUES (?, ?, ?, ?, ?, ?, ?)",+ batch.id.to_s, batch.start_seq, batch.end_seq,+ batch.merkle_root, batch.signature,+ batch.signing_key_version, batch.sealed_at.to_rfc3339,+ )+ end++ def last_sealed_seq : Int64+ result = @db.query_one?(+ "SELECT MAX(end_seq) FROM audit_batches",+ as: Int64?,+ )+ result || 0_i64+ end++ private def row_to_entry(row) : AuditEntry+ AuditEntry.new(+ seq: row[0],+ event_id: UUID.new(row[1]),+ occurred_at: Time.parse_rfc3339(row[2]),+ event_type: row[3],+ actor: row[4],+ target_id: row[5].try { |s| UUID.new(s) },+ payload: row[6],+ prev_hash: row[7],+ content_hash: row[8],+ hmac: row[9],+ hmac_key_version: row[10],+ )+ end+ end+enddiff --git a/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/credentials_repo.cr b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/credentials_repo.crnew file mode 100644index 00000000..ac7d4229--- /dev/null+++ b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/credentials_repo.cr@@ -0,0 +1,84 @@+# ===================+# ©AngelaMos | 2026+# credentials_repo.cr+# ===================++require "db"+require "json"+require "uuid"+require "../repos"+require "../../domain/credential"++module CRE::Persistence::Sqlite+ class CredentialsRepo < CRE::Persistence::CredentialsRepo+ SELECT_COLS = "id, external_id, kind, name, tags, current_version_id, pending_version_id, previous_version_id, created_at, updated_at"++ def initialize(@db : DB::Database)+ end++ def insert(c : Domain::Credential) : Nil+ @db.exec(+ "INSERT INTO credentials (id, external_id, kind, name, tags, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",+ c.id.to_s, c.external_id, c.kind.to_s, c.name,+ c.tags.to_json, c.created_at.to_rfc3339, c.updated_at.to_rfc3339,+ )+ end++ def update(c : Domain::Credential) : Nil+ @db.exec(+ "UPDATE credentials SET name = ?, tags = ?, current_version_id = ?, pending_version_id = ?, previous_version_id = ?, updated_at = ? WHERE id = ?",+ c.name, c.tags.to_json,+ c.current_version_id.try(&.to_s), c.pending_version_id.try(&.to_s), c.previous_version_id.try(&.to_s),+ Time.utc.to_rfc3339, c.id.to_s,+ )+ end++ def find(id : UUID) : Domain::Credential?+ @db.query_one?(+ "SELECT #{SELECT_COLS} FROM credentials WHERE id = ?",+ id.to_s,+ as: {String, String, String, String, String, String?, String?, String?, String, String},+ ).try { |row| row_to_credential(row) }+ end++ def find_by_external(kind : Domain::CredentialKind, external_id : String) : Domain::Credential?+ @db.query_one?(+ "SELECT #{SELECT_COLS} FROM credentials WHERE kind = ? AND external_id = ?",+ kind.to_s, external_id,+ as: {String, String, String, String, String, String?, String?, String?, String, String},+ ).try { |row| row_to_credential(row) }+ end++ def all : Array(Domain::Credential)+ @db.query_all(+ "SELECT #{SELECT_COLS} FROM credentials",+ as: {String, String, String, String, String, String?, String?, String?, String, String},+ ).map { |row| row_to_credential(row) }+ end++ def overdue(now : Time, max_age : Time::Span) : Array(Domain::Credential)+ cutoff = (now - max_age).to_rfc3339+ @db.query_all(+ "SELECT #{SELECT_COLS} FROM credentials WHERE updated_at < ?",+ cutoff,+ as: {String, String, String, String, String, String?, String?, String?, String, String},+ ).map { |row| row_to_credential(row) }+ end++ private def row_to_credential(row) : Domain::Credential+ tags = Hash(String, String).from_json(row[4])+ Domain::Credential.new(+ id: UUID.new(row[0]),+ external_id: row[1],+ kind: Domain::CredentialKind.parse(row[2]),+ name: row[3],+ tags: tags,+ current_version_id: row[5].try { |s| UUID.new(s) },+ pending_version_id: row[6].try { |s| UUID.new(s) },+ previous_version_id: row[7].try { |s| UUID.new(s) },+ created_at: Time.parse_rfc3339(row[8]),+ updated_at: Time.parse_rfc3339(row[9]),+ )+ end+ end+enddiff --git a/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/migrations.cr b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/migrations.crnew file mode 100644index 00000000..78e681fd--- /dev/null+++ b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/migrations.cr@@ -0,0 +1,92 @@+# ===================+# ©AngelaMos | 2026+# migrations.cr+# ===================++require "db"++module CRE::Persistence::Sqlite+ module Migrations+ SCHEMA = [+ <<-SQL,+ CREATE TABLE IF NOT EXISTS credentials (+ id TEXT PRIMARY KEY,+ external_id TEXT NOT NULL,+ kind TEXT NOT NULL,+ name TEXT NOT NULL,+ tags TEXT NOT NULL DEFAULT '{}',+ current_version_id TEXT,+ pending_version_id TEXT,+ previous_version_id TEXT,+ created_at TEXT NOT NULL,+ updated_at TEXT NOT NULL,+ UNIQUE (kind, external_id)+ )+ SQL+ <<-SQL,+ CREATE TABLE IF NOT EXISTS credential_versions (+ id TEXT PRIMARY KEY,+ credential_id TEXT NOT NULL REFERENCES credentials(id),+ ciphertext BLOB NOT NULL,+ dek_wrapped BLOB NOT NULL,+ kek_version INTEGER NOT NULL,+ algorithm_id INTEGER NOT NULL,+ metadata TEXT NOT NULL DEFAULT '{}',+ generated_at TEXT NOT NULL,+ revoked_at TEXT+ )+ SQL+ <<-SQL,+ CREATE TABLE IF NOT EXISTS rotations (+ id TEXT PRIMARY KEY,+ credential_id TEXT NOT NULL,+ rotator_kind TEXT NOT NULL,+ state TEXT NOT NULL,+ started_at TEXT NOT NULL,+ completed_at TEXT,+ step_outcomes TEXT NOT NULL DEFAULT '{}',+ failure_reason TEXT+ )+ SQL+ <<-SQL,+ CREATE TABLE IF NOT EXISTS audit_events (+ seq INTEGER PRIMARY KEY AUTOINCREMENT,+ event_id TEXT UNIQUE NOT NULL,+ occurred_at TEXT NOT NULL,+ event_type TEXT NOT NULL,+ actor TEXT NOT NULL,+ target_id TEXT,+ payload TEXT NOT NULL,+ prev_hash BLOB NOT NULL,+ content_hash BLOB NOT NULL,+ hmac BLOB NOT NULL,+ hmac_key_version INTEGER NOT NULL+ )+ SQL+ <<-SQL,+ CREATE TABLE IF NOT EXISTS audit_batches (+ id TEXT PRIMARY KEY,+ start_seq INTEGER NOT NULL,+ end_seq INTEGER NOT NULL,+ merkle_root BLOB NOT NULL,+ signature BLOB NOT NULL,+ signing_key_version INTEGER NOT NULL,+ sealed_at TEXT NOT NULL+ )+ SQL+ <<-SQL,+ CREATE TABLE IF NOT EXISTS kek_versions (+ version INTEGER PRIMARY KEY,+ source TEXT NOT NULL,+ source_ref TEXT,+ created_at TEXT NOT NULL,+ retired_at TEXT+ )+ SQL+ ]++ def self.run(db : DB::Database) : Nil+ SCHEMA.each { |stmt| db.exec(stmt) }+ end+ end+enddiff --git a/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/rotations_repo.cr b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/rotations_repo.crnew file mode 100644index 00000000..df72595f--- /dev/null+++ b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/rotations_repo.cr@@ -0,0 +1,56 @@+# ===================+# ©AngelaMos | 2026+# rotations_repo.cr+# ===================++require "db"+require "uuid"+require "../repos"++module CRE::Persistence::Sqlite+ class RotationsRepo < CRE::Persistence::RotationsRepo+ SELECT_COLS = "id, credential_id, rotator_kind, state, started_at, completed_at, failure_reason"++ def initialize(@db : DB::Database)+ end++ def insert(rotation : RotationRecord) : Nil+ @db.exec(+ "INSERT INTO rotations (id, credential_id, rotator_kind, state, started_at, completed_at, failure_reason) VALUES (?, ?, ?, ?, ?, ?, ?)",+ rotation.id.to_s, rotation.credential_id.to_s,+ rotation.rotator_kind.to_s, rotation.state.to_s,+ rotation.started_at.to_rfc3339,+ rotation.completed_at.try(&.to_rfc3339),+ rotation.failure_reason,+ )+ end++ def update_state(id : UUID, state : RotationState, error : String? = nil) : Nil+ completed_at = TERMINAL_STATES.includes?(state) ? Time.utc.to_rfc3339 : nil+ @db.exec(+ "UPDATE rotations SET state = ?, completed_at = ?, failure_reason = COALESCE(?, failure_reason) WHERE id = ?",+ state.to_s, completed_at, error, id.to_s,+ )+ end++ def in_flight : Array(RotationRecord)+ placeholders = TERMINAL_STATES.map { "?" }.join(",")+ args = TERMINAL_STATES.map { |s| s.to_s.as(DB::Any) }+ sql = "SELECT #{SELECT_COLS} FROM rotations WHERE state NOT IN (#{placeholders})"+ @db.query_all(sql, args: args, as: {String, String, String, String, String, String?, String?})+ .map { |row| row_to_record(row) }+ end++ private def row_to_record(row) : RotationRecord+ RotationRecord.new(+ id: UUID.new(row[0]),+ credential_id: UUID.new(row[1]),+ rotator_kind: RotatorKind.parse(row[2]),+ state: RotationState.parse(row[3]),+ started_at: Time.parse_rfc3339(row[4]),+ completed_at: row[5].try { |s| Time.parse_rfc3339(s) },+ failure_reason: row[6],+ )+ end+ end+enddiff --git a/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/sqlite_persistence.cr b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/sqlite_persistence.crnew file mode 100644index 00000000..58c61c69--- /dev/null+++ b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/sqlite_persistence.cr@@ -0,0 +1,77 @@+# ===================+# ©AngelaMos | 2026+# sqlite_persistence.cr+# ===================++require "db"+require "sqlite3"+require "../persistence"+require "./migrations"+require "./credentials_repo"+require "./versions_repo"+require "./rotations_repo"+require "./audit_repo"++module CRE::Persistence::Sqlite+ class SqlitePersistence < CRE::Persistence::Persistence+ @db : DB::Database+ @mutex : Mutex+ @credentials : CredentialsRepo?+ @versions : VersionsRepo?+ @rotations : RotationsRepo?+ @audit : AuditRepo?++ def initialize(path : String)+ uri = if path == ":memory:"+ "sqlite3:%3Amemory%3A?max_pool_size=1"+ else+ "sqlite3:#{path}?max_pool_size=1"+ end+ @db = DB.open(uri)+ @mutex = Mutex.new+ setup_pragmas+ end++ def credentials : CredentialsRepo+ @credentials ||= CredentialsRepo.new(@db)+ end++ def versions : VersionsRepo+ @versions ||= VersionsRepo.new(@db)+ end++ def rotations : RotationsRepo+ @rotations ||= RotationsRepo.new(@db)+ end++ def audit : AuditRepo+ @audit ||= AuditRepo.new(@db)+ end++ def transaction(&block : ->) : Nil+ @db.transaction { yield }+ end++ def with_advisory_lock(key : Int64, &block : ->) : Nil+ _ = key # SQLite is single-process; the mutex is sufficient+ @mutex.synchronize { yield }+ end++ def migrate! : Nil+ Migrations.run(@db)+ end++ def close : Nil+ @db.close+ end++ def db : DB::Database+ @db+ end++ private def setup_pragmas+ @db.exec("PRAGMA foreign_keys = ON")+ @db.exec("PRAGMA synchronous = NORMAL")+ end+ end+enddiff --git a/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/versions_repo.cr b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/versions_repo.crnew file mode 100644index 00000000..0688af6e--- /dev/null+++ b/PROJECTS/intermediate/credential-rotation-enforcer/src/cre/persistence/sqlite/versions_repo.cr@@ -0,0 +1,67 @@+# ===================+# ©AngelaMos | 2026+# versions_repo.cr+# ===================++require "db"+require "json"+require "uuid"+require "../repos"+require "../../domain/credential_version"++module CRE::Persistence::Sqlite+ class VersionsRepo < CRE::Persistence::VersionsRepo+ SELECT_COLS = "id, credential_id, ciphertext, dek_wrapped, kek_version, algorithm_id, metadata, generated_at, revoked_at"++ def initialize(@db : DB::Database)+ end++ def insert(v : Domain::CredentialVersion) : Nil+ @db.exec(+ "INSERT INTO credential_versions (id, credential_id, ciphertext, dek_wrapped, kek_version, algorithm_id, metadata, generated_at, revoked_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",+ v.id.to_s, v.credential_id.to_s,+ v.ciphertext, v.dek_wrapped,+ v.kek_version, v.algorithm_id.to_i32,+ v.metadata.to_json, v.generated_at.to_rfc3339,+ v.revoked_at.try(&.to_rfc3339),+ )+ end++ def find(id : UUID) : Domain::CredentialVersion?+ @db.query_one?(+ "SELECT #{SELECT_COLS} FROM credential_versions WHERE id = ?",+ id.to_s,+ as: {String, String, Bytes, Bytes, Int32, Int32, String, String, String?},+ ).try { |row| row_to_version(row) }+ end++ def for_credential(credential_id : UUID) : Array(Domain::CredentialVersion)+ @db.query_all(+ "SELECT #{SELECT_COLS} FROM credential_versions WHERE credential_id = ? ORDER BY generated_at DESC",+ credential_id.to_s,+ as: {String, String, Bytes, Bytes, Int32, Int32, String, String, String?},+ ).map { |row| row_to_version(row) }+ end++ def revoke(id : UUID, at : Time = Time.utc) : Nil+ @db.exec(+ "UPDATE credential_versions SET revoked_at = ? WHERE id = ?",+ at.to_rfc3339, id.to_s,+ )+ end++ private def row_to_version(row) : Domain::CredentialVersion+ Domain::CredentialVersion.new(+ id: UUID.new(row[0]),+ credential_id: UUID.new(row[1]),+ ciphertext: row[2],+ dek_wrapped: row[3],+ kek_version: row[4],+ algorithm_id: row[5].to_i16,+ metadata: Hash(String, String).from_json(row[6]),+ generated_at: Time.parse_rfc3339(row[7]),+ revoked_at: row[8].try { |s| Time.parse_rfc3339(s) },+ )+ end+ end+end