@read-frog/api-contract 0.11.1 → 0.12.0

package/src/index.ts

@@ -3,6 +3,7 @@ import { betaAccessContract } from "./contracts/beta-access"
 import { billingContract } from "./contracts/billing"
 import { cardContract } from "./contracts/card"
 import { cardTemplateContract } from "./contracts/card-template"
+import { ebookContract } from "./contracts/ebook"
 import { hostedAiContract } from "./contracts/hosted-ai"
 import { notebaseContract } from "./contracts/notebase"
 import { notebaseColumnContract } from "./contracts/notebase-column"
@@ -16,6 +17,7 @@ export const contract = {
   billing: billingContract,
   card: cardContract,
   cardTemplate: cardTemplateContract,
+  ebook: ebookContract,
   hostedAi: hostedAiContract,
   notebase: notebaseContract,
   notebaseColumn: notebaseColumnContract,
@@ -31,6 +33,7 @@ export * from "./public-errors"
 export * from "./schemas/beta-access"
 export * from "./schemas/billing"
 export * from "./schemas/card"
+export * from "./schemas/ebook"
 export * from "./schemas/hosted-ai"
 export * from "./schemas/notebase"
 export * from "./schemas/notebase-column"

package/src/public-errors.ts

@@ -157,6 +157,26 @@ export const PUBLIC_APP_ERROR_DEFS = {
     message: "Concurrent position conflict, please retry",
     status: 409,
   },
+  EBOOK_BETA_RESTRICTED: {
+    message: "Ebooks are currently in beta for selected accounts",
+    status: 403,
+  },
+  EBOOK_NOT_FOUND: {
+    message: "Ebook not found",
+    status: 404,
+  },
+  EBOOK_LIMIT_EXCEEDED: {
+    message: "Upgrade is required to upload more ebooks",
+    status: 403,
+  },
+  EBOOK_FILE_TOO_LARGE: {
+    message: "Ebook file exceeds the maximum allowed size",
+    status: 413,
+  },
+  EBOOK_UPLOAD_NOT_COMPLETED: {
+    message: "Ebook upload has not been completed",
+    status: 409,
+  },
 } as const satisfies Record<string, PublicAppErrorDefinition>
 
 export type PublicAppErrorCode = keyof typeof PUBLIC_APP_ERROR_DEFS

package/src/schemas/ebook.ts

@@ -0,0 +1,143 @@
+import { EBOOK_ALLOWED_COVER_CONTENT_TYPES } from "@read-frog/definitions"
+import { z } from "zod"
+
+export const ebookStatusSchema = z.enum(["pending", "ready"])
+export type EbookStatus = z.infer<typeof ebookStatusSchema>
+
+export const ebookCoverContentTypeSchema = z.enum(EBOOK_ALLOWED_COVER_CONTENT_TYPES)
+export type EbookCoverContentType = z.infer<typeof ebookCoverContentTypeSchema>
+
+export const ebookListItemSchema = z.object({
+  id: z.uuid(),
+  title: z.string(),
+  author: z.string().nullable(),
+  language: z.string().nullable(),
+  fileByteSize: z.number().int(),
+  status: ebookStatusSchema,
+  progressFraction: z.number(),
+  lastReadAt: z.coerce.date().nullable(),
+  coverUrl: z.url().nullable(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+}).strict()
+export type EbookListItem = z.infer<typeof ebookListItemSchema>
+
+export const ebookDetailSchema = ebookListItemSchema.extend({
+  progressCfi: z.string().nullable(),
+})
+export type EbookDetail = z.infer<typeof ebookDetailSchema>
+
+export const ebookQuotaSchema = z.object({
+  count: z.number().int().min(0),
+  // 0 is a valid limit: uploading is a paid feature, so free plans get no quota.
+  limit: z.number().int().min(0),
+}).strict()
+export type EbookQuota = z.infer<typeof ebookQuotaSchema>
+
+export const ebookListInputSchema = z.object({}).strict()
+export type EbookListInput = z.infer<typeof ebookListInputSchema>
+
+export const ebookListOutputSchema = z.object({
+  items: z.array(ebookListItemSchema),
+  quota: ebookQuotaSchema,
+}).strict()
+export type EbookListOutput = z.infer<typeof ebookListOutputSchema>
+
+export const ebookGetInputSchema = z.object({
+  id: z.uuid(),
+}).strict()
+export type EbookGetInput = z.infer<typeof ebookGetInputSchema>
+
+export const ebookGetOutputSchema = z.object({
+  ebook: ebookDetailSchema,
+}).strict()
+export type EbookGetOutput = z.infer<typeof ebookGetOutputSchema>
+
+export const ebookRequestUploadInputSchema = z.object({
+  title: z.string().min(1).max(500),
+  author: z.string().max(500).optional(),
+  language: z.string().max(35).optional(),
+  coverContentType: ebookCoverContentTypeSchema.optional(),
+}).strict()
+export type EbookRequestUploadInput = z.infer<typeof ebookRequestUploadInputSchema>
+
+/**
+ * S3 POST form policy. `fields` must be appended to the form in iteration order
+ * with the file last; S3 ignores anything sent after the `file` part.
+ */
+export const ebookPresignedPostSchema = z.object({
+  url: z.url(),
+  fields: z.record(z.string(), z.string()),
+}).strict()
+export type EbookPresignedPost = z.infer<typeof ebookPresignedPostSchema>
+
+export const ebookRequestUploadOutputSchema = z.object({
+  ebookId: z.uuid(),
+  upload: ebookPresignedPostSchema,
+  coverUpload: ebookPresignedPostSchema.nullable(),
+  expiresAt: z.coerce.date(),
+}).strict()
+export type EbookRequestUploadOutput = z.infer<typeof ebookRequestUploadOutputSchema>
+
+export const ebookFinalizeUploadInputSchema = z.object({
+  ebookId: z.uuid(),
+}).strict()
+export type EbookFinalizeUploadInput = z.infer<typeof ebookFinalizeUploadInputSchema>
+
+export const ebookFinalizeUploadOutputSchema = z.object({
+  ebook: ebookListItemSchema,
+}).strict()
+export type EbookFinalizeUploadOutput = z.infer<typeof ebookFinalizeUploadOutputSchema>
+
+export const ebookGetDownloadUrlInputSchema = z.object({
+  id: z.uuid(),
+}).strict()
+export type EbookGetDownloadUrlInput = z.infer<typeof ebookGetDownloadUrlInputSchema>
+
+export const ebookGetDownloadUrlOutputSchema = z.object({
+  url: z.url(),
+  expiresAt: z.coerce.date(),
+}).strict()
+export type EbookGetDownloadUrlOutput = z.infer<typeof ebookGetDownloadUrlOutputSchema>
+
+export const ebookUpdateProgressDataSchema = z.object({
+  cfi: z.string().max(2000),
+  fraction: z.number().min(0).max(1),
+}).strict()
+export type EbookUpdateProgressData = z.infer<typeof ebookUpdateProgressDataSchema>
+
+export const ebookUpdateProgressInputSchema = ebookUpdateProgressDataSchema.extend({
+  id: z.uuid(),
+})
+export type EbookUpdateProgressInput = z.infer<typeof ebookUpdateProgressInputSchema>
+
+export const ebookUpdateProgressOutputSchema = z.object({
+  lastReadAt: z.coerce.date(),
+}).strict()
+export type EbookUpdateProgressOutput = z.infer<typeof ebookUpdateProgressOutputSchema>
+
+export const ebookRenameDataSchema = z.object({
+  title: z.string().min(1).max(500),
+  author: z.string().max(500).nullable().optional(),
+}).strict()
+export type EbookRenameData = z.infer<typeof ebookRenameDataSchema>
+
+export const ebookRenameInputSchema = ebookRenameDataSchema.extend({
+  id: z.uuid(),
+})
+export type EbookRenameInput = z.infer<typeof ebookRenameInputSchema>
+
+export const ebookRenameOutputSchema = z.object({
+  ebook: ebookListItemSchema,
+}).strict()
+export type EbookRenameOutput = z.infer<typeof ebookRenameOutputSchema>
+
+export const ebookDeleteInputSchema = z.object({
+  id: z.uuid(),
+}).strict()
+export type EbookDeleteInput = z.infer<typeof ebookDeleteInputSchema>
+
+export const ebookDeleteOutputSchema = z.object({
+  id: z.uuid(),
+}).strict()
+export type EbookDeleteOutput = z.infer<typeof ebookDeleteOutputSchema>