Method into_session

crates/opencode-storage/src/repository.rs:45–101

(self)

impl SessionRow {
    fn into_session(self) -> Session {
        let summary = if self.summary_additions.is_some()
            || self.summary_deletions.is_some()
            || self.summary_files.is_some()
        {
            Some(SessionSummary {
                additions: self.summary_additions.unwrap_or(0) as u64,
                deletions: self.summary_deletions.unwrap_or(0) as u64,
                files: self.summary_files.unwrap_or(0) as u64,
                diffs: self
                    .summary_diffs
                    .and_then(|d| serde_json::from_str(&d).ok()),
            })
        } else {
            None
        };

        let created_dt = DateTime::from_timestamp_millis(self.created_at).unwrap_or_else(Utc::now);
        let updated_dt = DateTime::from_timestamp_millis(self.updated_at).unwrap_or_else(Utc::now);

        Session {
            id: self.id,
            slug: self.slug,
            project_id: self.project_id,
            directory: self.directory,
            parent_id: self.parent_id,
            title: self.title,
            version: self.version,
            time: SessionTime {
                created: self.created_at,
                updated: self.updated_at,
                compacting: self.time_compacting,
                archived: self.time_archived,
            },
            messages: vec![],
            summary,
            share: self.share_url.map(|url| SessionShare { url }),
            revert: self.revert.and_then(|r| serde_json::from_str(&r).ok()),
            permission: self.permission.and_then(|p| serde_json::from_str(&p).ok()),
            usage: if self.usage_input_tokens.is_some() {
                Some(SessionUsage {
                    input_tokens: self.usage_input_tokens.unwrap_or(0) as u64,
                    output_tokens: self.usage_output_tokens.unwrap_or(0) as u64,
                    reasoning_tokens: self.usage_reasoning_tokens.unwrap_or(0) as u64,
                    cache_write_tokens: self.usage_cache_write_tokens.unwrap_or(0) as u64,
                    cache_read_tokens: self.usage_cache_read_tokens.unwrap_or(0) as u64,
                    total_cost: self.usage_total_cost.unwrap_or(0.0),
                })
            } else {
                None
            },
            status: string_to_status(&self.status),
            metadata: HashMap::new(),
            created_at: created_dt,
            updated_at: updated_dt,
        }
    }
}