schema.prisma

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider        = "prisma-client-js"
  previewFeatures = ["deno"]
}

// generator dbml {
//   provider = "prisma-dbml-generator"
//   output   = "../generated/dbml"
// }

generator repco {
  provider = "repco-prisma-generate"
  output   = "../generated/repco"
}

enum ContentGroupingVariant {
  EPISODIC
  SERIAL
}

enum AgentType {
  DATASOURCE
  USER
}

// Core data model

model Repo {
  did      String   @id @unique
  name     String?  @unique
  head     String?  @unique
  tail     String?  @unique
  gateways String[]

  Head        Commit?      @relation("RepoToHead", fields: [head], references: [rootCid])
  Revision    Revision[]
  Commits     Commit[]
  Datasources DataSource[]
}

model Commit {
  rootCid   String   @id @unique
  commitCid String   @unique
  repoDid   String
  agentDid  String
  timestamp DateTime
  parent    String?  @unique

  Parent    Commit?    @relation("CommitHistory", fields: [parent], references: [rootCid])
  Next      Commit?    @relation("CommitHistory")
  Revisions Revision[] @relation("RevisionToCommit")
  Agent     Agent      @relation(fields: [agentDid], references: [did])
  IsHeadOf  Repo?      @relation("RepoToHead")
  Repo      Repo       @relation(fields: [repoDid], references: [did])
  // CommitBlock Block      @relation("CommitBlock", fields: [commitCid], references: [cid])
  // RootBlock   Block      @relation("RootBlock", fields: [rootCid], references: [cid])
}

model Agent {
  did       String     @id @unique
  type      AgentType?
  // DataSource DataSource?
  User      User?
  Revisions Revision[]
  Commit    Commit[]
}

model User {
  did   String @id @unique
  name  String
  Agent Agent  @relation(fields: [did], references: [did])
}

// model DurableCursor {
//   uid String @id @unique
//   cursor string
//   webhook string?
// }

model Ucans {
  scope    String
  audience String
  resource String
  token    String
  cid      String @id @unique
}

model DataSource {
  uid       String   @id @unique
  pluginUid String
  repoDid   String
  config    Json?
  cursor    String?
  active    Boolean?

  SourceRecords SourceRecord[]
  Repo          Repo           @relation(fields: [repoDid], references: [did])
}

enum KeypairScope {
  INSTANCE
  REPO
}

model Keypair {
  did    String       @id @unique
  scope  KeypairScope
  name   String?
  secret String
}

model FailedDatasourceFetches {
  uri           String
  datasourceUid String
  timestamp     DateTime
  errorMessage  String
  errorDetails  Json?

  @@id([uri, datasourceUid])
}

// model Cursor {
//   uid String @id @unique
// }

model Block {
  cid   String @id @unique
  bytes Bytes
  // Revision Revision? @relation("RevisionBlock")
  // Content  Revision? @relation("ContentBlock")
  // Commit   Commit?   @relation("CommitBlock")
  // Root     Commit?   @relation("RootBlock")
}

model Entity {
  uid        String @id @unique
  revisionId String @unique
  type       String

  Revision Revision   @relation(fields: [revisionId], references: [id])
  Metadata Metadata[]
}

model Revision {
  id String @id @unique

  // core relation scalars
  prevRevisionId String? @unique
  uid            String
  repoDid        String
  agentDid       String // did of writing agent (datasource or user)

  // core headers
  entityType   String
  dateModified DateTime
  dateCreated  DateTime
  isDeleted    Boolean  @default(false) // todo: better have publication status
  entityUris   String[]
  revisionUris String[]

  languages String @default("")

  // core derived fields
  contentCid  String // cid of content block
  revisionCid String @unique // cid of revision block

  // core relations
  Repo         Repo      @relation(fields: [repoDid], references: [did])
  Agent        Agent     @relation(fields: [agentDid], references: [did])
  // ContentBlock  Block     @relation("ContentBlock", fields: [contentCid], references: [cid])
  // RevisionBlock Block     @relation("RevisionBlock", fields: [revisionCid], references: [cid])
  PrevRevision Revision? @relation("RevisionHistory", fields: [prevRevisionId], references: [id])
  NextRevision Revision? @relation("RevisionHistory")
  Entity       Entity?
  Commit       Commit[]  @relation("RevisionToCommit")
  // Commit        Commit    @relation("RevisionToCommit", fields: [commitCid], references: [cid])

  derivedFromUid String?
  // TODO: This would have to be a lose relation as SourceRecords are not synced currently.
  // As this is not possible with prismma we skip defining the relation for now and have to query manually.
  // DerivedFrom SourceRecord? @relation("DerivedRevisions", fields: [derivedFromUid], references: [uid])

  // entity relations
  ContentGrouping    ContentGrouping?
  ContentItem        ContentItem?
  License            License?
  MediaAsset         MediaAsset?
  File               File?
  Concept            Concept?
  Contributor        Contributor?
  BroadcastEvent     BroadcastEvent?
  PublicationService PublicationService?
  Chapter            Chapter?
  Contribution       Contribution?
  Metadata           Metadata?
  Transcript         Transcript?
  Subtitles          Subtitles?
}

model SourceRecord {
  uid String @id @unique

  timestamp DateTime

  sourceUri           String
  containedEntityUris String[]

  /// MIME type
  contentType String
  /// Domain data model type identifier (any string)
  sourceType  String
  body        String
  meta        Json?

  dataSourceUid String?
  DataSource    DataSource? @relation(fields: [dataSourceUid], references: [uid])

  // DerivedRevisions Revision[] @relation("DerivedRevisions")
}

// Domain data model

/// @repco(Entity)
model ContentGrouping {
  uid        String @id @unique
  revisionId String @unique

  broadcastSchedule String? // TODO: JSON (channel, rrule)
  description       Json?
  groupingType      String // TODO: enum?
  startingDate      DateTime?
  subtitle          String?
  summary           Json?
  terminationDate   DateTime?
  title             Json                   @default("{}")
  variant           ContentGroupingVariant

  licenseUid String?

  License                License?      @relation(fields: [licenseUid], references: [uid])
  ContentItemsPrimary    ContentItem[] @relation("primaryGrouping")
  ContentItemsAdditional ContentItem[]
  Revision               Revision      @relation(fields: [revisionId], references: [id])
}

/// @repco(Entity)
model ContentItem {
  uid           String    @id @unique /// @zod.refine(imports.isValidUID)
  revisionId    String    @unique
  title         Json      @default("{}")
  subtitle      String?
  pubDate       DateTime? // TODO: Review this
  summary       Json?
  content       Json      @default("{}")
  contentFormat String
  contentUrl    String

  primaryGroupingUid    String?
  publicationServiceUid String?
  licenseUid            String?

  Revision            Revision            @relation(fields: [revisionId], references: [id])
  AdditionalGroupings ContentGrouping[]
  BroadcastEvents     BroadcastEvent[]
  Concepts            Concept[]
  Contributions       Contribution[]
  License             License?            @relation(fields: [licenseUid], references: [uid])
  MediaAssets         MediaAsset[]
  PrimaryGrouping     ContentGrouping?    @relation("primaryGrouping", fields: [primaryGroupingUid], references: [uid])
  PublicationService  PublicationService? @relation(fields: [publicationServiceUid], references: [uid])
}

/// @repco(Entity)
model License {
  uid        String @id @unique
  revisionId String @unique
  name       String

  Revision         Revision          @relation(fields: [revisionId], references: [id])
  ContentItems     ContentItem[]
  MediaAssets      MediaAsset[]
  ContentGroupings ContentGrouping[]
}

/// @repco(Entity)
model MediaAsset {
  uid         String @id @unique
  revisionId  String @unique
  title       Json   @default("{}")
  description Json?
  duration    Float?
  mediaType   String // TODO: Enum?

  teaserImageUid String?
  licenseUid     String?

  Revision      Revision       @relation(fields: [revisionId], references: [id])
  Files         File[]
  ContentItems  ContentItem[]
  Transcripts   Transcript[]
  Chapters      Chapter[]
  TeaserImage   File?          @relation("thumbnail", fields: [teaserImageUid], references: [uid])
  License       License?       @relation(fields: [licenseUid], references: [uid])
  Contributions Contribution[]
  Concepts      Concept[]
  // Translation   Translation[]
  Subtitles     Subtitles[]
}

/// @repco(Entity)
model Contribution {
  uid        String @id @unique
  revisionId String @unique
  role       String

  Contributor  Contributor[]
  ContentItems ContentItem[]
  MediaAssets  MediaAsset[]
  Revision     Revision      @relation(fields: [revisionId], references: [id])
}

/// @repco(Entity)
model Contributor {
  uid                  String @id @unique
  revisionId           String @unique
  name                 String
  personOrOrganization String
  contactInformation   String

  profilePictureUid String

  Revision         Revision             @relation(fields: [revisionId], references: [id])
  BroadcastService PublicationService[]
  Contributions    Contribution[]
  ProfilePicture   File?                @relation(fields: [profilePictureUid], references: [uid])
}

/// @repco(Entity)
model Chapter {
  uid        String @id @unique
  revisionId String @unique

  start    Float
  duration Float
  title    Json
  type     String // TODO: enum?

  mediaAssetUid String

  MediaAsset MediaAsset @relation(fields: [mediaAssetUid], references: [uid])
  Revision   Revision   @relation(fields: [revisionId], references: [id])
}

/// @repco(Entity)
model BroadcastEvent {
  uid        String @id @unique
  revisionId String @unique

  start    Float
  duration Float

  broadcastServiceUid String
  contentItemUid      String

  Revision         Revision           @relation(fields: [revisionId], references: [id])
  ContentItem      ContentItem        @relation(fields: [contentItemUid], references: [uid])
  BroadcastService PublicationService @relation(fields: [broadcastServiceUid], references: [uid])
}

/// @repco(Entity)
model PublicationService {
  uid        String @id @unique
  revisionId String @unique

  name      Json
  publisher Contributor? @relation(fields: [publisherUid], references: [uid])
  medium    String? // FM, Web, ...
  address   String

  publisherUid String?

  Revision        Revision         @relation(fields: [revisionId], references: [id])
  BroadcastEvents BroadcastEvent[]
  ContentItem     ContentItem[]
}

/// @repco(Entity)
model Transcript {
  uid         String @id @unique
  revisionId  String @unique
  language    String
  text        String
  engine      String
  subtitleUrl String // url to webvtt file (string)
  author      String // field for author (string)
  license     String // license field (string)

  mediaAssetUid String

  //TODO: Contributor relation
  MediaAsset MediaAsset @relation(fields: [mediaAssetUid], references: [uid])
  Revision   Revision   @relation(fields: [revisionId], references: [id])
}

// might not be needed?
/// @repco(Entity)
// model Translation {
//   uid      String @id @unique
//   language String
//   text     String
//   engine   String

//   mediaAssetUid String

//   MediaAsset MediaAsset @relation(fields: [mediaAssetUid], references: [uid])
// }

/// @repco(Entity)
model File {
  uid         String  @id @unique
  revisionId  String  @unique
  contentUrl  String
  contentSize Int? // size in bytes
  cid         String? // hash encoded as multihash (IPFS spec)

  mimeType           String?
  duration           Float?
  codec              String?
  bitrate            Int?
  resolution         String?
  additionalMetadata String?

  Revision      Revision      @relation(fields: [revisionId], references: [id])
  AsMediaAssets MediaAsset[]
  AsThumbnail   MediaAsset[]  @relation("thumbnail")
  contributors  Contributor[]
  AsSubtitles   Subtitles[]
}

enum ConceptKind {
  TAG
  CATEGORY
}

/// @repco(Entity)
model Concept {
  uid        String @id @unique
  revisionId String @unique

  originNamespace    String?
  kind               ConceptKind
  name               Json        @default("{}")
  summary            Json?
  description        Json?
  wikidataIdentifier String?
  sameAsUid          String?     @unique
  parentUid          String?

  Revision         Revision  @relation(fields: [revisionId], references: [id])
  SameAs           Concept?  @relation("isSameAs", fields: [sameAsUid], references: [uid])
  SameAsReverse    Concept?  @relation("isSameAs")
  ParentConcept    Concept?  @relation("parentConcept", fields: [parentUid], references: [uid])
  ChildrenConcepts Concept[] @relation("parentConcept")

  ContentItems ContentItem[]
  MediaAssets  MediaAsset[]
}

/// @repco(Entity)
model Metadata {
  uid        String @unique
  revisionId String @unique

  namespace String
  content   Json

  targetUid String

  Revision     Revision @relation(fields: [revisionId], references: [id])
  TargetEntity Entity   @relation(fields: [targetUid], references: [uid])
}

/// @repco(Entity)
model Subtitles {
  uid          String @id @unique
  revisionId   String @unique
  languageCode String

  Files         File[]
  MediaAsset    MediaAsset @relation(fields: [mediaAssetUid], references: [uid])
  mediaAssetUid String
  Revision      Revision   @relation(fields: [revisionId], references: [id])
}

model ApLocalActor {
  name    String @unique
  keypair Json
}

model ApFollows {
  localName String
  remoteId  String

  @@unique([localName, remoteId])
}

model ApActivities {
  id         String   @unique
  actorId    String
  type       String
  objectId   String
  receivedAt DateTime
  details    Json

  attributedTo String[]
}