@read-frog/api-contract 0.6.1 → 0.8.0

package/src/contracts/srs.ts

@@ -4,10 +4,27 @@ import {
   srsReviewOutputSchema,
   srsRollbackReviewInputSchema,
   srsRollbackReviewOutputSchema,
+  srsScheduleStatusStatsInputSchema,
+  srsScheduleStatusStatsOutputSchema,
+  srsSetCardBuriedInputSchema,
+  srsSetCardBuriedOutputSchema,
+  srsSetCardSuspendedInputSchema,
+  srsSetCardSuspendedOutputSchema,
 } from "#/schemas/srs"
 import { notebaseProcedure } from "./shared"
 
 export const srsContract = {
+  scheduleStatusStats: notebaseProcedure
+    .errors(pickPublicErrorMap("NOTEBASE_NOT_FOUND"))
+    .route({
+      method: "GET",
+      path: "/srs/schedule-status-stats",
+      summary: "List today schedule status stats for notebases",
+      tags: ["SRS"],
+    })
+    .input(srsScheduleStatusStatsInputSchema)
+    .output(srsScheduleStatusStatsOutputSchema),
+
   review: notebaseProcedure
     .errors(pickPublicErrorMap(
       "CARD_NOT_FOUND",
@@ -35,4 +52,34 @@ export const srsContract = {
     })
     .input(srsRollbackReviewInputSchema)
     .output(srsRollbackReviewOutputSchema),
+  setCardBuried: notebaseProcedure
+    .errors(pickPublicErrorMap(
+      "CARD_NOT_FOUND",
+      "CARD_ALREADY_BURIED",
+      "CARD_NOT_BURIED",
+      "CARD_STATUS_CHANGE_UNAVAILABLE",
+    ))
+    .route({
+      method: "POST",
+      path: "/srs/card/bury",
+      summary: "Manually bury or unbury a card",
+      tags: ["SRS"],
+    })
+    .input(srsSetCardBuriedInputSchema)
+    .output(srsSetCardBuriedOutputSchema),
+  setCardSuspended: notebaseProcedure
+    .errors(pickPublicErrorMap(
+      "CARD_NOT_FOUND",
+      "CARD_ALREADY_SUSPENDED",
+      "CARD_NOT_SUSPENDED",
+      "CARD_STATUS_CHANGE_UNAVAILABLE",
+    ))
+    .route({
+      method: "POST",
+      path: "/srs/card/suspend",
+      summary: "Manually suspend or unsuspend a card",
+      tags: ["SRS"],
+    })
+    .input(srsSetCardSuspendedInputSchema)
+    .output(srsSetCardSuspendedOutputSchema),
 }

package/src/contracts/user.ts

@@ -2,6 +2,8 @@ import { oc } from "@orpc/contract"
 import {
   userEnsureTimezoneInputSchema,
   userEnsureTimezoneOutputSchema,
+  userUpdateTimezoneInputSchema,
+  userUpdateTimezoneOutputSchema,
 } from "#/schemas/user"
 
 export const userContract = {
@@ -14,4 +16,13 @@ export const userContract = {
     })
     .input(userEnsureTimezoneInputSchema)
     .output(userEnsureTimezoneOutputSchema),
+  updateTimezone: oc
+    .route({
+      method: "PATCH",
+      path: "/users/me/timezone",
+      summary: "Update the authenticated user's timezone",
+      tags: ["Users"],
+    })
+    .input(userUpdateTimezoneInputSchema)
+    .output(userUpdateTimezoneOutputSchema),
 }

package/src/index.ts

@@ -2,6 +2,7 @@ import type { ContractRouterClient } from "@orpc/contract"
 import { betaAccessContract } from "./contracts/beta-access"
 import { cardContract } from "./contracts/card"
 import { cardTemplateContract } from "./contracts/card-template"
+import { hostedAiContract } from "./contracts/hosted-ai"
 import { notebaseContract } from "./contracts/notebase"
 import { notebaseColumnContract } from "./contracts/notebase-column"
 import { notebaseRowContract } from "./contracts/notebase-row"
@@ -12,6 +13,7 @@ export const contract = {
   betaAccess: betaAccessContract,
   card: cardContract,
   cardTemplate: cardTemplateContract,
+  hostedAi: hostedAiContract,
   notebase: notebaseContract,
   notebaseColumn: notebaseColumnContract,
   notebaseRow: notebaseRowContract,
@@ -24,6 +26,7 @@ export type ORPCRouterClient = ContractRouterClient<typeof contract>
 export * from "./public-errors"
 export * from "./schemas/beta-access"
 export * from "./schemas/card"
+export * from "./schemas/hosted-ai"
 export * from "./schemas/notebase"
 export * from "./schemas/notebase-column"
 export * from "./schemas/notebase-row"

package/src/public-errors.ts

@@ -82,6 +82,26 @@ export const PUBLIC_APP_ERROR_DEFS = {
     message: "Card review cannot be rolled back",
     status: 409,
   },
+  CARD_ALREADY_BURIED: {
+    message: "Card is already buried",
+    status: 409,
+  },
+  CARD_NOT_BURIED: {
+    message: "Card is not buried",
+    status: 409,
+  },
+  CARD_ALREADY_SUSPENDED: {
+    message: "Card is already suspended",
+    status: 409,
+  },
+  CARD_NOT_SUSPENDED: {
+    message: "Card is not suspended",
+    status: 409,
+  },
+  CARD_STATUS_CHANGE_UNAVAILABLE: {
+    message: "Card status change is unavailable",
+    status: 409,
+  },
   NOTEBASE_VIEW_NOT_FOUND: {
     message: "Notebase view not found",
     status: 404,

package/src/schemas/hosted-ai.ts

@@ -0,0 +1,46 @@
+import { z } from "zod"
+
+export const HostedAiOutputFieldTypeSchema = z.enum(["string", "number"])
+
+export const HostedAiOutputFieldSchema = z.strictObject({
+  name: z.string().trim().min(1).max(80),
+  type: HostedAiOutputFieldTypeSchema,
+})
+
+export const HostedAiStreamTextInputSchema = z.strictObject({
+  system: z.string().trim().min(1).max(16000),
+  prompt: z.string().trim().min(1).max(32000),
+  temperature: z.number().min(0).max(2).optional(),
+})
+
+export const HostedAiStreamStructuredObjectInputSchema = z.strictObject({
+  system: z.string().trim().min(1).max(16000),
+  prompt: z.string().trim().min(1).max(32000),
+  outputSchema: z.array(HostedAiOutputFieldSchema).min(1).max(32),
+  temperature: z.number().min(0).max(2).optional(),
+}).superRefine((input, ctx) => {
+  const fieldNames = new Set<string>()
+
+  input.outputSchema.forEach((field, index) => {
+    if (fieldNames.has(field.name)) {
+      ctx.addIssue({
+        code: "custom",
+        message: `Duplicate output schema name "${field.name}".`,
+        path: ["outputSchema", index, "name"],
+      })
+      return
+    }
+
+    fieldNames.add(field.name)
+  })
+})
+
+export const HostedAiStreamPartSchema = z.looseObject({
+  type: z.string().trim().min(1),
+})
+
+export type HostedAiOutputFieldType = z.infer<typeof HostedAiOutputFieldTypeSchema>
+export type HostedAiOutputField = z.infer<typeof HostedAiOutputFieldSchema>
+export type HostedAiStreamTextInput = z.infer<typeof HostedAiStreamTextInputSchema>
+export type HostedAiStreamStructuredObjectInput = z.infer<typeof HostedAiStreamStructuredObjectInputSchema>
+export type HostedAiStreamPart = z.infer<typeof HostedAiStreamPartSchema>

package/src/schemas/notebase.ts

@@ -1,4 +1,4 @@
-import { schedulingParamsShape, srsWeightsSchema } from "@read-frog/definitions"
+import { notebaseColumnConfigSchema, schedulingParamsShape, srsWeightsSchema } from "@read-frog/definitions"
 import { z } from "zod"
 import { notebaseColumnSchema } from "./notebase-column"
 import { notebaseRowSchema } from "./notebase-row"
@@ -38,6 +38,17 @@ export type Notebase = z.infer<typeof notebaseSchema>
 export const notebaseCreateDataSchema = z.object({
   id: z.uuid().optional(),
   name: z.string().min(1),
+  options: z.object({
+    initialColumns: z.array(z.object({
+      id: z.uuid(),
+      name: z.string().min(1),
+      config: notebaseColumnConfigSchema,
+    }).strict()).min(1),
+    initialRow: z.object({
+      id: z.uuid().optional(),
+      cells: z.record(z.string(), z.unknown()),
+    }).strict().optional(),
+  }).strict().optional(),
 }).strict()
 export type NotebaseCreateData = z.infer<typeof notebaseCreateDataSchema>
 
@@ -51,6 +62,8 @@ export type NotebaseCreateOutput = z.infer<typeof NotebaseCreateOutputSchema>
 
 export const notebaseUpdateDataSchema = z.object({
   name: z.string().min(1).optional(),
+  srsNewPerDay: schedulingParamsShape.newPerDay.optional(),
+  srsReviewsPerDay: schedulingParamsShape.reviewsPerDay.optional(),
 }).strict()
 export type NotebaseUpdateData = z.infer<typeof notebaseUpdateDataSchema>
 

package/src/schemas/srs.ts

@@ -1,4 +1,5 @@
 import {
+  activeScheduleStatusSchema,
   cardStateSchema,
   fsrsReviewLogSnapshotSchema,
   reviewRatingSchema,
@@ -53,6 +54,36 @@ export const srsRollbackReviewInputSchema = z.object({
 }).strict()
 export type SrsRollbackReviewInput = z.infer<typeof srsRollbackReviewInputSchema>
 
+export const srsScheduleStatusStatsSchema = z.record(
+  activeScheduleStatusSchema,
+  z.number().int().min(0),
+)
+export type SrsScheduleStatusStats = z.infer<typeof srsScheduleStatusStatsSchema>
+
+export const srsScheduleStatusStatsInputSchema = z.object({
+  notebaseIds: z.array(z.uuid()).optional(),
+  timezone: timezoneSchema,
+}).strict()
+export type SrsScheduleStatusStatsInput = z.infer<typeof srsScheduleStatusStatsInputSchema>
+
+export const srsScheduleStatusStatsOutputSchema = z.record(
+  z.uuid(),
+  srsScheduleStatusStatsSchema,
+)
+export type SrsScheduleStatusStatsOutput = z.infer<typeof srsScheduleStatusStatsOutputSchema>
+
+export const srsManualCardStatusInputSchema = z.object({
+  cardId: z.uuid(),
+  enabled: z.boolean(),
+}).strict()
+export type SrsManualCardStatusInput = z.infer<typeof srsManualCardStatusInputSchema>
+
+export const srsSetCardBuriedInputSchema = srsManualCardStatusInputSchema
+export type SrsSetCardBuriedInput = SrsManualCardStatusInput
+
+export const srsSetCardSuspendedInputSchema = srsManualCardStatusInputSchema
+export type SrsSetCardSuspendedInput = SrsManualCardStatusInput
+
 export const srsRevlogSchema = z.object({
   id: z.uuid(),
   notebaseId: z.uuid(),
@@ -67,6 +98,11 @@ export const srsRevlogSchema = z.object({
 })
 export type SrsRevlog = z.infer<typeof srsRevlogSchema>
 
+export const srsRevlogWithoutSnapshotSchema = srsRevlogSchema.omit({
+  fsrsReviewLogSnapshot: true,
+})
+export type SrsRevlogWithoutSnapshot = z.infer<typeof srsRevlogWithoutSnapshotSchema>
+
 export const srsReviewOutputSchema = z.object({
   card: cardSchema,
   revlog: srsRevlogSchema,
@@ -81,6 +117,17 @@ export const srsRollbackReviewOutputSchema = z.object({
 })
 export type SrsRollbackReviewOutput = z.infer<typeof srsRollbackReviewOutputSchema>
 
+export const srsTxidOutputSchema = z.object({
+  txid: z.number(),
+})
+export type SrsTxidOutput = z.infer<typeof srsTxidOutputSchema>
+
+export const srsSetCardBuriedOutputSchema = srsTxidOutputSchema
+export type SrsSetCardBuriedOutput = SrsTxidOutput
+
+export const srsSetCardSuspendedOutputSchema = srsTxidOutputSchema
+export type SrsSetCardSuspendedOutput = SrsTxidOutput
+
 function formatLastReviewTime(lastReviewTime: Date | string | null) {
   return lastReviewTime ? new Date(lastReviewTime).toISOString() : nullLastReviewTimeSentinel
 }
@@ -107,6 +154,7 @@ async function uuidV5(name: string, namespace: string) {
 
 function uuidToBytes(uuid: string) {
   const hex = uuid.replaceAll("-", "").toLowerCase()
+  /* v8 ignore next 3 -- SRS_REVIEW_CLIENT_ID_NAMESPACE is a fixed valid UUID. */
   if (!/^[0-9a-f]{32}$/.test(hex)) {
     throw new Error("Invalid UUID namespace")
   }

package/src/schemas/user.ts

@@ -11,3 +11,13 @@ export const userEnsureTimezoneOutputSchema = z.object({
   updated: z.boolean(),
 }).strict()
 export type UserEnsureTimezoneOutput = z.infer<typeof userEnsureTimezoneOutputSchema>
+
+export const userUpdateTimezoneInputSchema = z.object({
+  timezone: timezoneSchema,
+}).strict()
+export type UserUpdateTimezoneInput = z.infer<typeof userUpdateTimezoneInputSchema>
+
+export const userUpdateTimezoneOutputSchema = z.object({
+  timezone: timezoneSchema,
+}).strict()
+export type UserUpdateTimezoneOutput = z.infer<typeof userUpdateTimezoneOutputSchema>