jspg/src/lib.rs

use pgrx::*;

pg_module_magic!();

pub mod database;
pub mod drop;
pub mod jspg;
pub mod merger;
pub mod queryer;
pub mod validator;

use serde_json::json;
use std::sync::{Arc, RwLock};

lazy_static::lazy_static! {
  // Global Atomic Swap Container:
  // - RwLock: To protect the SWAP of the Option.
  // - Option: Because it starts empty.
  // - Arc: Because multiple running threads might hold the OLD engine while we swap.
  // - Jspg: The root semantic engine encapsulating the database metadata, validator, queryer, and merger.
  static ref GLOBAL_JSPG: RwLock<Option<Arc<jspg::Jspg>>> = RwLock::new(None);
}

#[pg_extern(strict)]
pub fn jspg_cache_database(database: JsonB) -> JsonB {
  let new_jspg = crate::jspg::Jspg::new(&database.0);
  let new_arc = Arc::new(new_jspg);

  // 3. ATOMIC SWAP
  {
    let mut lock = GLOBAL_JSPG.write().unwrap();
    *lock = Some(new_arc);
  }

  let drop = crate::drop::Drop::success();
  JsonB(serde_json::to_value(drop).unwrap())
}
// `mask_json_schema` has been removed as the mask architecture is fully replaced by Spi string queries during DB interactions.

#[pg_extern(strict, parallel_safe)]
pub fn validate_json_schema(schema_id: &str, instance: JsonB) -> JsonB {
  // 1. Acquire Snapshot
  let jspg_arc = {
    let lock = GLOBAL_JSPG.read().unwrap();
    lock.clone()
  };

  // 2. Validate (Lock-Free)
  if let Some(engine) = jspg_arc {
    match engine.validator.validate(schema_id, &instance.0) {
      Ok(result) => {
        if result.is_valid() {
          let drop = crate::drop::Drop::success();
          JsonB(serde_json::to_value(drop).unwrap())
        } else {
          let errors: Vec<crate::drop::Error> = result
            .errors
            .into_iter()
            .map(|e| crate::drop::Error {
              code: e.code,
              message: e.message,
              details: crate::drop::ErrorDetails { path: e.path },
            })
            .collect();
          let drop = crate::drop::Drop::with_errors(errors);
          JsonB(serde_json::to_value(drop).unwrap())
        }
      }
      Err(e) => {
        let error = crate::drop::Error {
          code: e.code,
          message: e.message,
          details: crate::drop::ErrorDetails { path: e.path },
        };
        let drop = crate::drop::Drop::with_errors(vec![error]);
        JsonB(serde_json::to_value(drop).unwrap())
      }
    }
  } else {
    let error = crate::drop::Error {
      code: "VALIDATOR_NOT_INITIALIZED".to_string(),
      message: "The JSPG database has not been cached yet. Run jspg_cache_database()".to_string(),
      details: crate::drop::ErrorDetails {
        path: "".to_string(),
      },
    };
    let drop = crate::drop::Drop::with_errors(vec![error]);
    JsonB(serde_json::to_value(drop).unwrap())
  }
}

#[pg_extern(strict, parallel_safe)]
pub fn json_schema_cached(schema_id: &str) -> bool {
  if let Some(engine) = GLOBAL_JSPG.read().unwrap().as_ref() {
    match engine
      .validator
      .validate(schema_id, &serde_json::Value::Null)
    {
      Err(e) if e.code == "SCHEMA_NOT_FOUND" => false,
      _ => true,
    }
  } else {
    false
  }
}

#[pg_extern(strict)]
pub fn clear_json_schemas() -> JsonB {
  let mut lock = GLOBAL_JSPG.write().unwrap();
  *lock = None;
  let drop = crate::drop::Drop::success();
  JsonB(serde_json::to_value(drop).unwrap())
}

#[pg_extern(strict, parallel_safe)]
pub fn show_json_schemas() -> JsonB {
  if let Some(engine) = GLOBAL_JSPG.read().unwrap().as_ref() {
    let mut keys = engine.validator.get_schema_ids();
    keys.sort();
    let drop = crate::drop::Drop::success_with_val(json!(keys));
    JsonB(serde_json::to_value(drop).unwrap())
  } else {
    let drop = crate::drop::Drop::success_with_val(json!([]));
    JsonB(serde_json::to_value(drop).unwrap())
  }
}

#[cfg(any(test, feature = "pg_test"))]
#[pg_schema]
mod tests {
  use pgrx::prelude::*;
  include!("tests/fixtures.rs");
}

#[cfg(test)]
pub mod pg_test {
  pub fn setup(_options: Vec<&str>) {
    // perform any initialization common to all tests
  }

  pub fn postgresql_conf_options() -> Vec<&'static str> {
    // return any postgresql.conf settings that are required for your tests
    vec![]
  }
}