feat: push objects on client sync

apps/cacvote-jx-terminal/backend/src/db.rs

@@ -13,7 +13,7 @@ use base64_serde::base64_serde_type;
 use sqlx::postgres::PgPoolOptions;
 use sqlx::{Connection, PgPool};
 use tracing::Level;
-use types_rs::cacvote::{JournalEntry, JurisdictionCode};
+use types_rs::cacvote::{JournalEntry, JurisdictionCode, SignedObject};
 
 use crate::config::Config;
 
@@ -81,3 +81,40 @@ pub(crate) async fn get_latest_journal_entry(
     .fetch_optional(&mut *connection)
     .await?)
 }
+
+pub(crate) async fn get_unsynced_objects(
+    executor: &mut sqlx::PgConnection,
+) -> color_eyre::eyre::Result<Vec<SignedObject>> {
+    Ok(sqlx::query_as!(
+        SignedObject,
+        r#"
+        SELECT
+            id,
+            payload,
+            certificates,
+            signature
+        FROM objects
+        WHERE server_synced_at IS NULL
+        "#,
+    )
+    .fetch_all(&mut *executor)
+    .await?)
+}
+
+pub(crate) async fn mark_object_synced(
+    executor: &mut sqlx::PgConnection,
+    id: uuid::Uuid,
+) -> color_eyre::eyre::Result<()> {
+    sqlx::query!(
+        r#"
+        UPDATE objects
+        SET server_synced_at = now()
+        WHERE id = $1
+        "#,
+        id
+    )
+    .execute(&mut *executor)
+    .await?;
+
+    Ok(())
+}

apps/cacvote-jx-terminal/backend/src/sync.rs

@@ -41,6 +41,16 @@ pub(crate) async fn sync(
 ) -> color_eyre::eyre::Result<()> {
     client.check_status().await?;
 
+    push_objects(executor, client).await?;
+    pull_journal_entries(executor, client).await?;
+
+    Ok(())
+}
+
+async fn pull_journal_entries(
+    executor: &mut sqlx::PgConnection,
+    client: &Client,
+) -> color_eyre::eyre::Result<()> {
     let latest_journal_entry_id = db::get_latest_journal_entry(executor)
         .await?
         .map(|entry| entry.id);
@@ -54,3 +64,16 @@ pub(crate) async fn sync(
 
     Ok(())
 }
+
+async fn push_objects(
+    executor: &mut sqlx::PgConnection,
+    client: &Client,
+) -> color_eyre::eyre::Result<()> {
+    let objects = db::get_unsynced_objects(executor).await?;
+    for object in objects {
+        let object_id = client.create_object(object).await?;
+        db::mark_object_synced(executor, object_id).await?;
+    }
+
+    Ok(())
+}

apps/cacvote-mark/backend/bin/create-object

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+require('esbuild-runner/register');
+
+require('../src/bin/create-object/main')
+  .main(process.argv, {
+    stdin: process.stdin,
+    stdout: process.stdout,
+    stderr: process.stderr,
+  })
+  .then((code) => {
+    process.exitCode = code;
+  })
+  .catch((err) => {
+    console.error(err.stack);
+    process.exit(1);
+  });

apps/cacvote-mark/backend/package.json

@@ -71,6 +71,7 @@
     "@types/uuid": "9.0.5",
     "@types/xml": "^1.0.9",
     "@votingworks/test-utils": "workspace:*",
+    "esbuild-runner": "2.2.2",
     "eslint": "8.51.0",
     "eslint-config-prettier": "^9.0.0",
     "eslint-import-resolver-node": "^0.3.9",

apps/cacvote-mark/backend/src/bin/create-object/main.ts

@@ -0,0 +1,55 @@
+import { Buffer } from 'buffer';
+import { readFile } from 'fs/promises';
+import { cryptography } from '@votingworks/auth';
+import { v4 } from 'uuid';
+import { Readable } from 'stream';
+import { unsafeParse } from '@votingworks/types';
+import { join } from 'path';
+import { Payload, SignedObject, UuidSchema } from '../../cacvote-server/types';
+import { resolveWorkspace } from '../../workspace';
+
+const DEV_CERTS_PATH = join(__dirname, '../../../../../../libs/auth/certs/dev');
+const PRIVATE_KEY_PATH = join(DEV_CERTS_PATH, 'vx-admin-private-key.pem');
+const VX_ADMIN_CERT_AUTHORITY_CERT_PATH = join(
+  DEV_CERTS_PATH,
+  'vx-admin-cert-authority-cert.pem'
+);
+
+export async function main(): Promise<void> {
+  const workspace = await resolveWorkspace();
+
+  interface TestObject {
+    name: string;
+    description: string;
+    value: number;
+  }
+
+  const object: TestObject = {
+    name: 'Test Object',
+    description: 'This is a test object',
+    value: 42,
+  };
+
+  const payload = new Payload(
+    'TestObject',
+    Buffer.from(JSON.stringify(object))
+  );
+
+  const certificatesPem = await readFile(VX_ADMIN_CERT_AUTHORITY_CERT_PATH);
+  const payloadBuffer = Buffer.from(JSON.stringify(payload));
+  const signature = await cryptography.signMessage({
+    message: Readable.from(payloadBuffer),
+    signingPrivateKey: {
+      source: 'file',
+      path: PRIVATE_KEY_PATH,
+    },
+  });
+  const signedObject = new SignedObject(
+    unsafeParse(UuidSchema, v4()),
+    payloadBuffer,
+    certificatesPem,
+    signature
+  );
+
+  console.log(await workspace.store.addObject(signedObject));
+}