@read-frog/api-contract 0.4.1 → 0.6.1

package/src/schemas/srs.ts

@@ -0,0 +1,129 @@
+import {
+  cardStateSchema,
+  fsrsReviewLogSnapshotSchema,
+  reviewRatingSchema,
+  scheduleStatusSchema,
+  schedulingParamsSchema,
+  SRS_REVIEW_DURATION_MS_MAX,
+  srsStepSchema,
+} from "@read-frog/definitions"
+import { z } from "zod"
+import { cardSchema } from "./card"
+import { timezoneSchema } from "./timezone"
+
+export {
+  reviewRatingSchema,
+  schedulingParamsSchema,
+  SRS_REVIEW_DURATION_MS_MAX,
+}
+export { timezoneSchema } from "./timezone"
+export type { Timezone } from "./timezone"
+export type { ReviewRating, SchedulingParams } from "@read-frog/definitions"
+
+export const stepSchema = srsStepSchema
+export type Step = z.infer<typeof stepSchema>
+
+export const SRS_REVIEW_CLIENT_ID_NAMESPACE = "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+const srsReviewClientIdNamePrefix = "readfrog:srs-review"
+const nullLastReviewTimeSentinel = "null"
+
+export interface SrsReviewClientIdCard {
+  id: string
+  lastReviewTime: Date | string | null
+}
+
+export async function createSrsReviewClientId(card: SrsReviewClientIdCard) {
+  return uuidV5(
+    `${srsReviewClientIdNamePrefix}:${card.id}:${formatLastReviewTime(card.lastReviewTime)}`,
+    SRS_REVIEW_CLIENT_ID_NAMESPACE,
+  )
+}
+
+export const srsReviewInputSchema = z.object({
+  cardId: z.uuid(),
+  id: z.uuid().optional(),
+  rating: reviewRatingSchema,
+  durationMs: z.number().int().min(0).max(SRS_REVIEW_DURATION_MS_MAX),
+  timezone: timezoneSchema,
+}).strict()
+export type SrsReviewInput = z.infer<typeof srsReviewInputSchema>
+
+export const srsRollbackReviewInputSchema = z.object({
+  cardId: z.uuid(),
+}).strict()
+export type SrsRollbackReviewInput = z.infer<typeof srsRollbackReviewInputSchema>
+
+export const srsRevlogSchema = z.object({
+  id: z.uuid(),
+  notebaseId: z.uuid(),
+  cardId: z.uuid(),
+  rating: reviewRatingSchema,
+  state: cardStateSchema,
+  afterScheduleStatus: scheduleStatusSchema,
+  reviewedAt: z.coerce.date(),
+  durationMs: z.number().int(),
+  fsrsReviewLogSnapshot: fsrsReviewLogSnapshotSchema,
+  createdAt: z.coerce.date(),
+})
+export type SrsRevlog = z.infer<typeof srsRevlogSchema>
+
+export const srsReviewOutputSchema = z.object({
+  card: cardSchema,
+  revlog: srsRevlogSchema,
+  txid: z.number(),
+})
+export type SrsReviewOutput = z.infer<typeof srsReviewOutputSchema>
+
+export const srsRollbackReviewOutputSchema = z.object({
+  card: cardSchema,
+  rolledBackRevlogId: z.uuid(),
+  txid: z.number(),
+})
+export type SrsRollbackReviewOutput = z.infer<typeof srsRollbackReviewOutputSchema>
+
+function formatLastReviewTime(lastReviewTime: Date | string | null) {
+  return lastReviewTime ? new Date(lastReviewTime).toISOString() : nullLastReviewTimeSentinel
+}
+
+async function uuidV5(name: string, namespace: string) {
+  const namespaceBytes = uuidToBytes(namespace)
+  const nameBytes = new TextEncoder().encode(name)
+  const input = new Uint8Array(namespaceBytes.length + nameBytes.length)
+  input.set(namespaceBytes)
+  input.set(nameBytes, namespaceBytes.length)
+
+  const hash = new Uint8Array(await crypto.subtle.digest("SHA-1", input))
+  const bytes = hash.slice(0, 16)
+  const versionByte = bytes[6]
+  const variantByte = bytes[8]
+  if (versionByte === undefined || variantByte === undefined) {
+    throw new Error("SHA-1 digest was too short")
+  }
+  bytes[6] = (versionByte & 0x0F) | 0x50
+  bytes[8] = (variantByte & 0x3F) | 0x80
+
+  return bytesToUuid(bytes)
+}
+
+function uuidToBytes(uuid: string) {
+  const hex = uuid.replaceAll("-", "").toLowerCase()
+  if (!/^[0-9a-f]{32}$/.test(hex)) {
+    throw new Error("Invalid UUID namespace")
+  }
+
+  return new Uint8Array(
+    Array.from({ length: 16 }, (_, index) =>
+      Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16)),
+  )
+}
+
+function bytesToUuid(bytes: Uint8Array) {
+  const hex = Array.from(bytes, byte => byte.toString(16).padStart(2, "0"))
+  return [
+    hex.slice(0, 4).join(""),
+    hex.slice(4, 6).join(""),
+    hex.slice(6, 8).join(""),
+    hex.slice(8, 10).join(""),
+    hex.slice(10, 16).join(""),
+  ].join("-")
+}

package/src/schemas/timezone.ts

@@ -0,0 +1,23 @@
+import { z } from "zod"
+
+// @ref https://zenn.dev/herp_inc/articles/js-intl-date-time-format-performance
+const localeTimeZoneFormatter = new Map<string, Intl.DateTimeFormat>()
+function createTimezoneFormatter(timezone: string): Intl.DateTimeFormat {
+  let formatter = localeTimeZoneFormatter.get(timezone)
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", { timeZone: timezone })
+    localeTimeZoneFormatter.set(timezone, formatter)
+  }
+  return formatter
+}
+
+export const timezoneSchema = z.string().trim().min(1).refine((timezone) => {
+  try {
+    createTimezoneFormatter(timezone).format(new Date())
+    return true
+  }
+  catch {
+    return false
+  }
+}, "Invalid timezone")
+export type Timezone = z.infer<typeof timezoneSchema>

package/src/schemas/user.ts

@@ -0,0 +1,13 @@
+import { z } from "zod"
+import { timezoneSchema } from "./timezone"
+
+export const userEnsureTimezoneInputSchema = z.object({
+  timezone: timezoneSchema,
+}).strict()
+export type UserEnsureTimezoneInput = z.infer<typeof userEnsureTimezoneInputSchema>
+
+export const userEnsureTimezoneOutputSchema = z.object({
+  timezone: timezoneSchema,
+  updated: z.boolean(),
+}).strict()
+export type UserEnsureTimezoneOutput = z.infer<typeof userEnsureTimezoneOutputSchema>

package/src/contracts/column.ts

@@ -1,62 +0,0 @@
-import { pickPublicErrorMap } from "@/public-errors"
-import {
-  ColumnCreateInputSchema,
-  ColumnCreateOutputSchema,
-  ColumnDeleteInputSchema,
-  ColumnDeleteOutputSchema,
-  ColumnReorderInputSchema,
-  ColumnReorderOutputSchema,
-  ColumnUpdateInputSchema,
-  ColumnUpdateOutputSchema,
-} from "@/schemas/column"
-import { notebaseProcedure } from "./shared"
-
-export const columnContract = {
-  create: notebaseProcedure
-    .errors(pickPublicErrorMap("TABLE_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT"))
-    .route({
-      method: "POST",
-      path: "/columns",
-      summary: "Create column",
-      tags: ["Columns"],
-    })
-    .input(ColumnCreateInputSchema)
-    .output(ColumnCreateOutputSchema),
-
-  update: notebaseProcedure
-    .errors(pickPublicErrorMap("COLUMN_NOT_FOUND"))
-    .route({
-      method: "PATCH",
-      path: "/columns/{columnId}",
-      summary: "Update column",
-      tags: ["Columns"],
-    })
-    .input(ColumnUpdateInputSchema)
-    .output(ColumnUpdateOutputSchema),
-
-  delete: notebaseProcedure
-    .errors(pickPublicErrorMap(
-      "COLUMN_NOT_FOUND",
-      "PRIMARY_COLUMN_DELETE_NOT_ALLOWED",
-      "CONCURRENT_POSITION_CONFLICT",
-    ))
-    .route({
-      method: "DELETE",
-      path: "/columns/{columnId}",
-      summary: "Delete column",
-      tags: ["Columns"],
-    })
-    .input(ColumnDeleteInputSchema)
-    .output(ColumnDeleteOutputSchema),
-
-  reorder: notebaseProcedure
-    .errors(pickPublicErrorMap("TABLE_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT"))
-    .route({
-      method: "POST",
-      path: "/columns/reorder",
-      summary: "Reorder columns in a table",
-      tags: ["Columns"],
-    })
-    .input(ColumnReorderInputSchema)
-    .output(ColumnReorderOutputSchema),
-}

package/src/contracts/custom-table.ts

@@ -1,82 +0,0 @@
-import { pickPublicErrorMap } from "@/public-errors"
-import {
-  CustomTableCreateInputSchema,
-  CustomTableCreateOutputSchema,
-  CustomTableDeleteInputSchema,
-  CustomTableDeleteOutputSchema,
-  CustomTableGetInputSchema,
-  CustomTableGetOutputSchema,
-  CustomTableGetSchemaInputSchema,
-  CustomTableGetSchemaOutputSchema,
-  CustomTableListInputSchema,
-  CustomTableListOutputSchema,
-  CustomTableUpdateInputSchema,
-  CustomTableUpdateOutputSchema,
-} from "@/schemas/custom-table"
-import { notebaseProcedure } from "./shared"
-
-export const customTableContract = {
-  list: notebaseProcedure
-    .route({
-      method: "GET",
-      path: "/custom-tables",
-      summary: "List custom tables",
-      tags: ["Custom Tables"],
-    })
-    .input(CustomTableListInputSchema)
-    .output(CustomTableListOutputSchema),
-
-  get: notebaseProcedure
-    .errors(pickPublicErrorMap("TABLE_NOT_FOUND"))
-    .route({
-      method: "GET",
-      path: "/custom-tables/{id}",
-      summary: "Get custom table with columns, rows, and views",
-      tags: ["Custom Tables"],
-    })
-    .input(CustomTableGetInputSchema)
-    .output(CustomTableGetOutputSchema),
-
-  getSchema: notebaseProcedure
-    .errors(pickPublicErrorMap("TABLE_NOT_FOUND"))
-    .route({
-      method: "GET",
-      path: "/custom-tables/{id}/schema",
-      summary: "Get custom table schema",
-      tags: ["Custom Tables"],
-    })
-    .input(CustomTableGetSchemaInputSchema)
-    .output(CustomTableGetSchemaOutputSchema),
-
-  create: notebaseProcedure
-    .route({
-      method: "POST",
-      path: "/custom-tables",
-      summary: "Create custom table",
-      tags: ["Custom Tables"],
-    })
-    .input(CustomTableCreateInputSchema)
-    .output(CustomTableCreateOutputSchema),
-
-  update: notebaseProcedure
-    .errors(pickPublicErrorMap("TABLE_NOT_FOUND"))
-    .route({
-      method: "PUT",
-      path: "/custom-tables/{id}",
-      summary: "Update custom table",
-      tags: ["Custom Tables"],
-    })
-    .input(CustomTableUpdateInputSchema)
-    .output(CustomTableUpdateOutputSchema),
-
-  delete: notebaseProcedure
-    .errors(pickPublicErrorMap("TABLE_NOT_FOUND"))
-    .route({
-      method: "DELETE",
-      path: "/custom-tables/{id}",
-      summary: "Delete custom table",
-      tags: ["Custom Tables"],
-    })
-    .input(CustomTableDeleteInputSchema)
-    .output(CustomTableDeleteOutputSchema),
-}

package/src/contracts/row.ts

@@ -1,62 +0,0 @@
-import { pickPublicErrorMap } from "@/public-errors"
-import {
-  RowCreateInputSchema,
-  RowCreateOutputSchema,
-  RowDeleteInputSchema,
-  RowDeleteOutputSchema,
-  RowReorderInputSchema,
-  RowReorderOutputSchema,
-  RowUpdateInputSchema,
-  RowUpdateOutputSchema,
-} from "@/schemas/row"
-import { notebaseProcedure } from "./shared"
-
-export const rowContract = {
-  create: notebaseProcedure
-    .errors(pickPublicErrorMap(
-      "TABLE_NOT_FOUND",
-      "CELL_VALIDATION_FAILED",
-      "CONCURRENT_POSITION_CONFLICT",
-    ))
-    .route({
-      method: "POST",
-      path: "/rows",
-      summary: "Create row",
-      tags: ["Rows"],
-    })
-    .input(RowCreateInputSchema)
-    .output(RowCreateOutputSchema),
-
-  update: notebaseProcedure
-    .errors(pickPublicErrorMap("ROW_NOT_FOUND", "CELL_VALIDATION_FAILED"))
-    .route({
-      method: "PATCH",
-      path: "/rows/{rowId}",
-      summary: "Update row cells",
-      tags: ["Rows"],
-    })
-    .input(RowUpdateInputSchema)
-    .output(RowUpdateOutputSchema),
-
-  delete: notebaseProcedure
-    .errors(pickPublicErrorMap("ROW_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT"))
-    .route({
-      method: "DELETE",
-      path: "/rows/{rowId}",
-      summary: "Delete row",
-      tags: ["Rows"],
-    })
-    .input(RowDeleteInputSchema)
-    .output(RowDeleteOutputSchema),
-
-  reorder: notebaseProcedure
-    .errors(pickPublicErrorMap("TABLE_NOT_FOUND", "CONCURRENT_POSITION_CONFLICT"))
-    .route({
-      method: "POST",
-      path: "/rows/reorder",
-      summary: "Reorder rows in a table",
-      tags: ["Rows"],
-    })
-    .input(RowReorderInputSchema)
-    .output(RowReorderOutputSchema),
-}

package/src/schemas/column.ts

@@ -1,74 +0,0 @@
-import { COLUMN_MAX_WIDTH, COLUMN_MIN_WIDTH, columnConfigSchema } from "@read-frog/definitions"
-import { z } from "zod"
-
-export const columnWidthSchema = z.number().int().min(COLUMN_MIN_WIDTH).max(COLUMN_MAX_WIDTH)
-
-export const tableColumnSchema = z.object({
-  id: z.string(),
-  tableId: z.string(),
-  name: z.string(),
-  config: columnConfigSchema,
-  position: z.number(),
-  isPrimary: z.boolean(),
-  width: z.number().nullable(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-})
-export type TableColumn = z.infer<typeof tableColumnSchema>
-
-export const columnCreateDataSchema = z.object({
-  id: z.uuid().optional(),
-  name: z.string().min(1),
-  config: columnConfigSchema,
-}).strict()
-export type ColumnCreateData = z.infer<typeof columnCreateDataSchema>
-
-export const columnUpdateDataSchema = z.object({
-  name: z.string().min(1).optional(),
-  config: columnConfigSchema.optional(),
-  width: columnWidthSchema.nullable().optional(),
-}).strict()
-export type ColumnUpdateData = z.infer<typeof columnUpdateDataSchema>
-
-export const ColumnCreateInputSchema = z.object({
-  tableId: z.uuid(),
-  data: columnCreateDataSchema,
-})
-export type ColumnCreateInput = z.infer<typeof ColumnCreateInputSchema>
-
-export const ColumnCreateOutputSchema = z.object({
-  txid: z.number(),
-})
-export type ColumnCreateOutput = z.infer<typeof ColumnCreateOutputSchema>
-
-export const ColumnUpdateInputSchema = z.object({
-  columnId: z.uuid(),
-  data: columnUpdateDataSchema,
-})
-export type ColumnUpdateInput = z.infer<typeof ColumnUpdateInputSchema>
-
-export const ColumnUpdateOutputSchema = z.object({
-  txid: z.number(),
-})
-export type ColumnUpdateOutput = z.infer<typeof ColumnUpdateOutputSchema>
-
-export const ColumnDeleteInputSchema = z.object({
-  columnId: z.uuid(),
-})
-export type ColumnDeleteInput = z.infer<typeof ColumnDeleteInputSchema>
-
-export const ColumnDeleteOutputSchema = z.object({
-  txid: z.number(),
-})
-export type ColumnDeleteOutput = z.infer<typeof ColumnDeleteOutputSchema>
-
-export const ColumnReorderInputSchema = z.object({
-  tableId: z.uuid(),
-  ids: z.array(z.uuid()),
-})
-export type ColumnReorderInput = z.infer<typeof ColumnReorderInputSchema>
-
-export const ColumnReorderOutputSchema = z.object({
-  txid: z.number(),
-})
-export type ColumnReorderOutput = z.infer<typeof ColumnReorderOutputSchema>

package/src/schemas/custom-table.ts

@@ -1,86 +0,0 @@
-import { z } from "zod"
-import { tableColumnSchema } from "./column"
-import { tableRowSchema } from "./row"
-import { tableViewSchema } from "./view"
-
-export const CustomTableListInputSchema = z.object({})
-export type CustomTableListInput = z.infer<typeof CustomTableListInputSchema>
-
-export const CustomTableListItemSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-})
-export type CustomTableListItem = z.infer<typeof CustomTableListItemSchema>
-
-export const CustomTableListOutputSchema = z.array(CustomTableListItemSchema)
-export type CustomTableListOutput = z.infer<typeof CustomTableListOutputSchema>
-
-export const customTableCreateDataSchema = z.object({
-  id: z.uuid().optional(),
-  name: z.string().min(1),
-}).strict()
-export type CustomTableCreateData = z.infer<typeof customTableCreateDataSchema>
-
-export const CustomTableCreateInputSchema = customTableCreateDataSchema
-export type CustomTableCreateInput = z.infer<typeof CustomTableCreateInputSchema>
-
-export const CustomTableCreateOutputSchema = z.object({
-  txid: z.number(),
-})
-export type CustomTableCreateOutput = z.infer<typeof CustomTableCreateOutputSchema>
-
-export const customTableUpdateDataSchema = z.object({
-  name: z.string().min(1).optional(),
-}).strict()
-export type CustomTableUpdateData = z.infer<typeof customTableUpdateDataSchema>
-
-export const CustomTableUpdateInputSchema = customTableUpdateDataSchema.extend({
-  id: z.uuid(),
-})
-export type CustomTableUpdateInput = z.infer<typeof CustomTableUpdateInputSchema>
-
-export const CustomTableUpdateOutputSchema = z.object({
-  txid: z.number(),
-})
-export type CustomTableUpdateOutput = z.infer<typeof CustomTableUpdateOutputSchema>
-
-export const CustomTableDeleteInputSchema = z.object({
-  id: z.uuid(),
-})
-export type CustomTableDeleteInput = z.infer<typeof CustomTableDeleteInputSchema>
-
-export const CustomTableDeleteOutputSchema = z.object({
-  txid: z.number(),
-})
-export type CustomTableDeleteOutput = z.infer<typeof CustomTableDeleteOutputSchema>
-
-// Get endpoint schemas
-export const CustomTableGetInputSchema = z.object({
-  id: z.uuid(),
-})
-export type CustomTableGetInput = z.infer<typeof CustomTableGetInputSchema>
-
-export const CustomTableGetSchemaInputSchema = z.object({
-  id: z.uuid(),
-})
-export type CustomTableGetSchemaInput = z.infer<typeof CustomTableGetSchemaInputSchema>
-
-export const CustomTableGetOutputSchema = z.object({
-  id: z.string(),
-  userId: z.string(),
-  name: z.string(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-  columns: z.array(tableColumnSchema),
-  rows: z.array(tableRowSchema),
-  views: z.array(tableViewSchema),
-})
-export type CustomTableGetOutput = z.infer<typeof CustomTableGetOutputSchema>
-
-export const CustomTableGetSchemaOutputSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  updatedAt: z.coerce.date(),
-  columns: z.array(tableColumnSchema),
-})
-export type CustomTableGetSchemaOutput = z.infer<typeof CustomTableGetSchemaOutputSchema>

package/src/schemas/row.ts

@@ -1,73 +0,0 @@
-import { z } from "zod"
-
-export const rowCellsSchema = z.record(z.string(), z.unknown())
-
-export const tableRowSchema = z.object({
-  id: z.string(),
-  tableId: z.string(),
-  cells: rowCellsSchema,
-  position: z.number(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-})
-export type TableRow = z.infer<typeof tableRowSchema>
-
-export const rowCreateDataSchema = z.object({
-  id: z.uuid().optional(),
-  cells: rowCellsSchema.optional(),
-}).strict()
-export type RowCreateData = z.infer<typeof rowCreateDataSchema>
-
-export const rowUpdateDataSchema = z.object({
-  cells: rowCellsSchema.optional(),
-}).strict()
-export type RowUpdateData = z.infer<typeof rowUpdateDataSchema>
-
-export const RowCreateInputSchema = z.object({
-  tableId: z.uuid(),
-  data: rowCreateDataSchema,
-})
-export type RowCreateInput = z.infer<typeof RowCreateInputSchema>
-
-export const RowCreateOutputSchema = z.object({
-  txid: z.number(),
-})
-export type RowCreateOutput = z.infer<typeof RowCreateOutputSchema>
-
-export const RowUpdateInputSchema = z.object({
-  rowId: z.uuid(),
-  data: rowUpdateDataSchema,
-})
-export type RowUpdateInput = z.infer<typeof RowUpdateInputSchema>
-
-export const RowUpdateOutputSchema = z.object({
-  id: z.uuid(),
-  tableId: z.uuid(),
-  cells: rowCellsSchema,
-  position: z.number().int(),
-  createdAt: z.date(),
-  updatedAt: z.date(),
-  txid: z.number(),
-})
-export type RowUpdateOutput = z.infer<typeof RowUpdateOutputSchema>
-
-export const RowDeleteInputSchema = z.object({
-  rowId: z.uuid(),
-})
-export type RowDeleteInput = z.infer<typeof RowDeleteInputSchema>
-
-export const RowDeleteOutputSchema = z.object({
-  txid: z.number(),
-})
-export type RowDeleteOutput = z.infer<typeof RowDeleteOutputSchema>
-
-export const RowReorderInputSchema = z.object({
-  tableId: z.uuid(),
-  ids: z.array(z.uuid()),
-})
-export type RowReorderInput = z.infer<typeof RowReorderInputSchema>
-
-export const RowReorderOutputSchema = z.object({
-  txid: z.number(),
-})
-export type RowReorderOutput = z.infer<typeof RowReorderOutputSchema>

package/src/schemas/view.ts

@@ -1,61 +0,0 @@
-import { z } from "zod"
-
-export const tableViewTypeSchema = z.enum(["table", "kanban", "gallery"])
-export type TableViewType = z.infer<typeof tableViewTypeSchema>
-
-export const viewConfigSchema = z.object({
-  columnWidths: z.record(z.string(), z.number()).optional(),
-  hiddenColumns: z.array(z.string()).optional(),
-  groupByColumnId: z.string().optional(),
-}).catchall(z.unknown())
-export type ViewConfig = z.infer<typeof viewConfigSchema>
-
-export const viewFilterSchema = z.object({
-  columnId: z.string(),
-  operator: z.string(),
-  value: z.unknown(),
-}).strict()
-export type ViewFilter = z.infer<typeof viewFilterSchema>
-
-export const viewFiltersSchema = z.array(viewFilterSchema)
-
-export const viewSortSchema = z.object({
-  columnId: z.string(),
-  direction: z.enum(["asc", "desc"]),
-}).strict()
-export type ViewSort = z.infer<typeof viewSortSchema>
-
-export const viewSortsSchema = z.array(viewSortSchema)
-
-export const viewCreateDataSchema = z.object({
-  id: z.uuid().optional(),
-  name: z.string().min(1),
-  type: tableViewTypeSchema,
-  config: viewConfigSchema.optional(),
-  filters: viewFiltersSchema.optional(),
-  sorts: viewSortsSchema.optional(),
-}).strict()
-export type ViewCreateData = z.infer<typeof viewCreateDataSchema>
-
-export const viewUpdateDataSchema = z.object({
-  name: z.string().min(1).optional(),
-  type: tableViewTypeSchema.optional(),
-  config: viewConfigSchema.optional(),
-  filters: viewFiltersSchema.optional(),
-  sorts: viewSortsSchema.optional(),
-}).strict()
-export type ViewUpdateData = z.infer<typeof viewUpdateDataSchema>
-
-export const tableViewSchema = z.object({
-  id: z.string(),
-  tableId: z.string(),
-  name: z.string(),
-  type: tableViewTypeSchema,
-  config: viewConfigSchema.nullable(),
-  filters: z.array(z.unknown()).nullable(),
-  sorts: z.array(z.unknown()).nullable(),
-  position: z.number(),
-  createdAt: z.coerce.date(),
-  updatedAt: z.coerce.date(),
-})
-export type TableView = z.infer<typeof tableViewSchema>