use nu_engine::CallExt;
use nu_protocol::engine::{Call, Command, EngineState, Stack};
use nu_protocol::shell_error::generic::GenericError;
use nu_protocol::{
Category, PipelineData, Record, ShellError, Signature, SyntaxShape, Type, Value,
};
use serde_json::Value as JsonValue;
use crate::nu::util;
fn scru128_error(msg: String, span: nu_protocol::Span) -> ShellError {
ShellError::Generic(GenericError::new("SCRU128 Error", msg, span))
}
#[allow(clippy::result_large_err)]
fn get_string_input(
call: &Call,
engine_state: &EngineState,
stack: &mut Stack,
input: PipelineData,
span: nu_protocol::Span,
) -> Result<String, ShellError> {
if let Some(id) = call.opt::<String>(engine_state, stack, 1)? {
Ok(id)
} else {
match input {
PipelineData::Value(Value::String { val, .. }, _) => Ok(val),
_ => Err(ShellError::Generic(
GenericError::new("Missing input", "String required", span)
.with_help("Provide string as argument or via pipeline"),
)),
}
}
}
#[allow(clippy::result_large_err)]
fn get_record_input(
call: &Call,
engine_state: &EngineState,
stack: &mut Stack,
input: PipelineData,
span: nu_protocol::Span,
) -> Result<Value, ShellError> {
if let Some(arg) = call.opt::<Value>(engine_state, stack, 1)? {
Ok(arg)
} else {
match input {
PipelineData::Value(val @ Value::Record { .. }, _) => Ok(val),
_ => Err(ShellError::Generic(
GenericError::new("Missing input", "Record required", span)
.with_help("Provide record as argument or via pipeline"),
)),
}
}
}
fn add_when_field(nu_value: Value, span: nu_protocol::Span) -> Value {
if let Value::Record { val: record, .. } = &nu_value {
if let Some(Value::Int { val: ts_ms, .. }) = record.get("ts_ms") {
let when = Value::date(
chrono::DateTime::from_timestamp_millis(*ts_ms)
.unwrap_or_else(chrono::Utc::now)
.into(),
span,
);
let mut new_record = Record::new();
for (key, value) in record.iter() {
new_record.push(key.clone(), value.clone());
if key == "ts_ms" {
new_record.push("when".to_string(), when.clone());
}
}
return Value::record(new_record, span);
}
}
nu_value
}
fn drop_when_field(mut json_value: JsonValue) -> JsonValue {
if let JsonValue::Object(ref mut obj) = json_value {
obj.remove("when");
}
json_value
}
#[derive(Clone, Default)]
pub struct Scru128Command;
impl Scru128Command {
pub fn new() -> Self {
Self
}
}
impl Command for Scru128Command {
fn name(&self) -> &str {
".id"
}
fn signature(&self) -> Signature {
Signature::build(".id")
.input_output_types(vec![
(Type::Nothing, Type::String),
(Type::String, Type::Record(vec![].into())),
(Type::Record(vec![].into()), Type::String),
])
.optional(
"subcommand",
SyntaxShape::String,
"subcommand: 'unpack' or 'pack'",
)
.optional(
"input",
SyntaxShape::Any,
"input for subcommand (ID string for unpack, record for pack)",
)
.category(Category::Experimental)
}
fn description(&self) -> &str {
"Generate SCRU128 IDs or manipulate them with unpack/pack operations"
}
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
let span = call.head;
let subcommand: Option<String> = call.opt(engine_state, stack, 0)?;
match subcommand.as_deref() {
Some("unpack") => {
let id_string = get_string_input(call, engine_state, stack, input, span)?;
let result = crate::scru128::unpack_to_json(&id_string)
.map_err(|e| scru128_error(format!("Failed to unpack ID: {e}"), span))?;
let nu_value = util::json_to_value(&result, span);
let nu_value = add_when_field(nu_value, span);
Ok(PipelineData::Value(nu_value, None))
}
Some("pack") => {
let components = get_record_input(call, engine_state, stack, input, span)?;
let json_value = util::value_to_json(&components);
let json_value = drop_when_field(json_value);
let result = crate::scru128::pack_from_json(json_value)
.map_err(|e| scru128_error(format!("Failed to pack components: {e}"), span))?;
Ok(PipelineData::Value(Value::string(result, span), None))
}
Some(unknown) => Err(ShellError::Generic(
GenericError::new(
"Invalid subcommand",
format!("Unknown subcommand: {unknown}"),
span,
)
.with_help("Available subcommands: unpack, pack"),
)),
None => {
let result = crate::scru128::generate()
.map_err(|e| scru128_error(format!("Failed to generate ID: {e}"), span))?;
Ok(PipelineData::Value(Value::string(result, span), None))
}
}
}
}