Applications

package provider
 
import (
  "context"
  "encoding/json"
  "net/http"
  "time"
 
  gestalt "github.com/valon-technologies/gestalt/sdk/go"
  "github.com/valon-technologies/gestalt/sdk/go/client"
)
 
type Provider struct{}
 
type SaveItemInput struct {
  ID     string `json:"id" required:"true"`
  Title  string `json:"title" required:"true"`
  Status string `json:"status" required:"true"`
}
 
type SaveItemOutput struct {
  OK bool `json:"ok"`
}
 
func (p *Provider) saveItem(
  ctx context.Context,
  input SaveItemInput,
  _ gestalt.Request,
) (gestalt.Response[SaveItemOutput], error) {
  db, err := gestalt.IndexedDB(ctx)
  if err != nil {
    return gestalt.Response[SaveItemOutput]{}, err
  }
  defer db.Close()
 
  items := db.ObjectStore("items")
  if err := items.Put(ctx, gestalt.Record{
    "id":        input.ID,
    "title":     input.Title,
    "status":    input.Status,
    "updatedAt": time.Now().UTC().Format(time.RFC3339),
  }); err != nil {
    return gestalt.Response[SaveItemOutput]{}, err
  }
  return gestalt.OK(SaveItemOutput{OK: true}), nil
}
 
type NightlyReportInput struct{}
 
type NightlyReportOutput struct {
  ReportURL string `json:"reportUrl"`
}
 
func (p *Provider) generateNightly(
  ctx context.Context,
  input NightlyReportInput,
  req gestalt.Request,
) (gestalt.Response[NightlyReportOutput], error) {
  db, err := gestalt.IndexedDB(ctx)
  if err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
  defer db.Close()
 
  s3, err := client.ConnectS3(ctx, "reports")
  if err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
 
  body, err := json.Marshal(map[string]string{
    "generatedAt": time.Now().UTC().Format(time.RFC3339),
  })
  if err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
  ref := &client.S3ObjectRef{Key: "nightly/" + req.IdempotencyKey + ".json"}
  stream, err := s3.WriteObject(ctx, &client.WriteObjectOpen{
    Ref:         ref,
    ContentType: "application/json",
  })
  if err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
  if err := stream.Send(body); err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
  if _, err := stream.CloseAndRecv(); err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
  access, err := s3.PresignObject(
    ctx, client.PresignMethodGet, 900, ref,
    &client.S3PresignObjectOptions{ContentType: "application/json"},
  )
  if err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
 
  if err := db.ObjectStore("reports").Put(ctx, gestalt.Record{
    "id":        req.IdempotencyKey,
    "url":       access.Url,
    "createdAt": time.Now().UTC().Format(time.RFC3339),
  }); err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
 
  workflows, err := gestalt.WorkflowFromContext(ctx)
  if err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
  _, err = workflows.DeliverEvent(ctx, &client.WorkflowEvent{
    Type:            "workspace_review.report.generated",
    Source:          "workspace_review",
    Subject:         "nightly",
    Datacontenttype: "application/json",
    Data:            map[string]any{"reportUrl": access.Url},
  }, nil)
  if err != nil {
    return gestalt.Response[NightlyReportOutput]{}, err
  }
 
  return gestalt.OK(NightlyReportOutput{ReportURL: access.Url}), nil
}
 
var Router = gestalt.MustRouter(
  gestalt.Register(
    gestalt.Operation[SaveItemInput, SaveItemOutput]{
      ID: "items.save", Method: http.MethodPost,
    },
    (*Provider).saveItem,
  ),
  gestalt.Register(
    gestalt.Operation[NightlyReportInput, NightlyReportOutput]{
      ID: "reports.generateNightly", Method: http.MethodPost,
    },
    (*Provider).generateNightly,
  ),
)

import datetime as dt
import json
 
from gestalt import (
    App,
    Model,
    IndexedDB,
    PresignMethodValues,
    Request,
    S3,
    S3ObjectRef,
    WriteObjectOpen,
    WorkflowEvent,
    WorkflowDeliverEvent,
)
 
app = App("workspace_review")
 
class SaveItemInput(Model):
    id: str
    title: str
    status: str
 
@app.operation(id="items.save", method="POST")
def save_item(input: SaveItemInput) -> dict[str, bool]:
    db = IndexedDB()
    db.object_store("items").put(
        {
            "id": input.id,
            "title": input.title,
            "status": input.status,
            "updatedAt": dt.datetime.now(dt.timezone.utc).isoformat(),
        }
    )
    db.close()
    return {"ok": True}
 
@app.operation(id="reports.generateNightly", method="POST")
def generate_nightly(request: Request) -> dict[str, str]:
    db = IndexedDB()
    s3 = S3.connect("reports")
 
    ref = S3ObjectRef(key=f"nightly/{request.idempotency_key}.json")
    body = json.dumps(
        {"generatedAt": dt.datetime.now(dt.timezone.utc).isoformat()}
    ).encode()
    s3.write_object(
        WriteObjectOpen(ref=ref, content_type="application/json"),
        [body],
    )
    access = s3.presign_object(
        method=PresignMethodValues.GET,
        expires_seconds=900,
        ref=ref,
    )
 
    db.object_store("reports").put(
        {
            "id": request.idempotency_key,
            "url": access.url,
            "createdAt": dt.datetime.now(dt.timezone.utc).isoformat(),
        }
    )
 
    with request.workflows() as workflows:
        workflows.deliver_event(
            WorkflowDeliverEvent(
                event=WorkflowEvent(
                    type="workspace_review.report.generated",
                    source="workspace_review",
                    subject="nightly",
                    datacontenttype="application/json",
                    data={"reportUrl": access.url},
                )
            )
        )
 
    db.close()
    return {"reportUrl": access.url}

use std::collections::BTreeMap;
 
use gestalt::s3::{S3ObjectRef, S3PresignObjectOptions, WriteObjectOpen, presign_method};
use gestalt::workflow::{WorkflowDeliverEventOptions, WorkflowEvent};
use gestalt::{IndexedDB, S3, Workflow};
use serde::{Deserialize, Serialize};
use serde_json::json;
 
#[derive(Deserialize)]
struct SaveItemInput {
    id: String,
    title: String,
    status: String,
}
 
#[derive(Serialize)]
struct SaveItemOutput {
    ok: bool,
}
 
async fn save_item(input: SaveItemInput) -> Result<SaveItemOutput, Box<dyn std::error::Error>> {
    let db = IndexedDB::connect().await?;
    let mut items = db.object_store("items");
    let updated_at = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)?
        .as_secs()
        .to_string();
 
    items
        .put(BTreeMap::from([
            ("id".to_string(), json!(input.id)),
            ("title".to_string(), json!(input.title)),
            ("status".to_string(), json!(input.status)),
            ("updatedAt".to_string(), json!(updated_at)),
        ]))
        .await?;
 
    Ok(SaveItemOutput { ok: true })
}
 
#[derive(Serialize)]
struct NightlyReportOutput {
    report_url: String,
}
 
async fn generate_nightly(
    request: &gestalt::Request,
) -> Result<NightlyReportOutput, Box<dyn std::error::Error>> {
    let db = IndexedDB::connect().await?;
    let mut reports = db.object_store("reports");
    let generated_at = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)?
        .as_secs()
        .to_string();
 
    let mut s3 = S3::connect_named("reports").await?;
    let key = format!("nightly/{}.json", request.idempotency_key);
    let body = serde_json::to_vec(&json!({ "generatedAt": generated_at.clone() }))?;
    s3.write_object(
        WriteObjectOpen {
            r#ref: Some(S3ObjectRef {
                key: key.clone(),
                ..Default::default()
            }),
            content_type: "application/json".to_string(),
            ..Default::default()
        },
        tokio_stream::once(body),
    )
    .await?;
    let access = s3
        .presign_object(
            presign_method::PRESIGN_METHOD_GET,
            900,
            Some(S3ObjectRef {
                key,
                ..Default::default()
            }),
            S3PresignObjectOptions {
                content_type: "application/json".to_string(),
                ..Default::default()
            },
        )
        .await?;
 
    reports
        .put(BTreeMap::from([
            ("id".to_string(), json!(request.idempotency_key)),
            ("url".to_string(), json!(access.url.clone())),
            ("createdAt".to_string(), json!(generated_at)),
        ]))
        .await?;
 
    let mut workflows = Workflow::connect().await?;
    workflows
        .deliver_event(
            Some(WorkflowEvent {
                r#type: "workspace_review.report.generated".to_string(),
                source: "workspace_review".to_string(),
                subject: "nightly".to_string(),
                datacontenttype: "application/json".to_string(),
                data: json!({ "reportUrl": access.url.clone() })
                    .as_object()
                    .cloned(),
                ..Default::default()
            }),
            WorkflowDeliverEventOptions::default(),
        )
        .await?;
 
    Ok(NightlyReportOutput {
        report_url: access.url,
    })
}

import {
  IndexedDB,
  PresignMethod,
  S3,
  Workflow,
  defineApp,
  ok,
  operation,
  s,
} from "@valon-technologies/gestalt";
 
export const app = defineApp({
  operations: [
    operation({
      id: "items.save",
      method: "POST",
      input: s.object({
        id: s.string(),
        title: s.string(),
        status: s.string(),
      }),
      output: s.object({ ok: s.boolean() }),
      async handler(input) {
        const db = new IndexedDB();
        await db.objectStore("items").put({
          id: input.id,
          title: input.title,
          status: input.status,
          updatedAt: new Date().toISOString(),
        });
        return ok({ ok: true });
      },
    }),
    operation({
      id: "reports.generateNightly",
      method: "POST",
      input: s.object({}),
      output: s.object({ reportUrl: s.string() }),
      async handler(_input, request) {
        const db = new IndexedDB();
        const s3 = S3.connect({ name: "reports" });
        const ref = { key: `nightly/${request.idempotencyKey}.json` };
 
        const body = new TextEncoder().encode(
          JSON.stringify({ generatedAt: new Date().toISOString() }),
        );
        await s3.writeObject(
          { ref, contentType: "application/json" },
          (async function* () {
            yield body;
          })(),
        );
        const access = await s3.presignObject(PresignMethod.GET, 900n, ref, {
          contentType: "application/json",
        });
 
        await db.objectStore("reports").put({
          id: request.idempotencyKey,
          url: access.url,
          createdAt: new Date().toISOString(),
        });
 
        const workflows = Workflow.connect();
        await workflows.deliverEvent({
          type: "workspace_review.report.generated",
          source: "workspace_review",
          subject: "nightly",
          datacontenttype: "application/json",
          data: { reportUrl: access.url },
        });
 
        return ok({ reportUrl: access.url });
      },
    }),
  ],
});

import (
    "context"
 
    gestalt "github.com/valon-technologies/gestalt/sdk/go"
    "github.com/valon-technologies/gestalt/sdk/go/client"
)
 
func loadLinkedIssue(ctx context.Context, request gestalt.Request, issueNumber int) (map[string]any, error) {
    app, err := gestalt.AppFromContext(ctx)
    if err != nil {
        return nil, err
    }
 
    // Invoke decodes the standard JSON operation envelope; payload
    // failures return *client.InvokeError. Use InvokeRaw for the raw
    // status, headers, and body.
    return client.JSONResultAs[map[string]any](app.Invoke(
        ctx,
        "github",
        "issues.get",
        map[string]any{
            "owner":  "acme",
            "repo":   "roadmap",
            "number": issueNumber,
        },
        &client.AppInvokeOptions{
            Connection:     "default",
            IdempotencyKey: request.IdempotencyKey,
            RunAs: &client.SubjectContext{
                ID: "service_account:nightly-sync",
            },
            CredentialMode: "none",
        },
    ))
}

from gestalt import Request
 
def load_linked_issue(
    request: Request,
    issue_number: int,
) -> dict[str, object]:
    app = request.app()
    # invoke decodes the standard JSON operation envelope; payload
    # failures raise InvokeError. Use invoke_raw for the raw status,
    # headers, and body.
    return app.invoke(
        app="github",
        operation="issues.get",
        params={
            "owner": "acme",
            "repo": "roadmap",
            "number": issue_number,
        },
        connection="default",
        idempotency_key=request.idempotency_key,
    )

use gestalt::app::{AppInvokeOptions, RequestContext, SubjectContext};
use gestalt::{App, Request};
use serde_json::{json, Value};
 
async fn load_linked_issue(
    request: &Request,
    issue_number: i64,
) -> Result<Value, Box<dyn std::error::Error>> {
    let context = RequestContext {
        subject: Some(SubjectContext {
            id: request.subject.id.clone(),
            ..Default::default()
        }),
        ..Default::default()
    };
    let mut app = App::connect().await?.with_context(context);
 
    let params = json!({
        "owner": "acme",
        "repo": "roadmap",
        "number": issue_number,
    })
    .as_object()
    .cloned();
 
    // invoke decodes the standard JSON operation envelope; payload and
    // transport failures both surface as InvokeError. Use invoke_raw for
    // the raw status, headers, and body.
    let issue = app
        .invoke(
            "github".to_string(),
            "issues.get".to_string(),
            params,
            AppInvokeOptions {
                connection: "default".to_string(),
                idempotency_key: request.idempotency_key.clone(),
                ..Default::default()
            },
        )
        .await?;
 
    Ok(issue)
}

import { type Request } from "@valon-technologies/gestalt";
 
export async function loadLinkedIssue(request: Request, issueNumber: number) {
  const app = await request.app();
 
  // invoke decodes the standard JSON operation envelope; payload
  // failures throw InvokeError. Use invokeRaw for the raw status,
  // headers, and body.
  return await app.invoke<Record<string, unknown>>(
    "github",
    "issues.get",
    {
      owner: "acme",
      repo: "roadmap",
      number: issueNumber,
    },
    {
      connection: "default",
      idempotencyKey: request.idempotencyKey,
    },
  );
}