@read-frog/api-contract 0.14.0 → 0.16.0

package/src/schemas/notebase-column.ts

@@ -1,7 +1,16 @@
-import { NOTEBASE_COLUMN_MAX_WIDTH, NOTEBASE_COLUMN_MIN_WIDTH, notebaseColumnConfigSchema } from "@read-frog/definitions"
-import { z } from "zod"
+import { deletionResultSchema, expectedUpdatedAtSchema } from "./resource-mutation";
+import {
+  NOTEBASE_COLUMN_MAX_WIDTH,
+  NOTEBASE_COLUMN_MIN_WIDTH,
+  notebaseColumnConfigSchema,
+} from "@read-frog/definitions";
+import { z } from "zod";
 
-export const notebaseColumnWidthSchema = z.number().int().min(NOTEBASE_COLUMN_MIN_WIDTH).max(NOTEBASE_COLUMN_MAX_WIDTH)
+export const notebaseColumnWidthSchema = z
+  .number()
+  .int()
+  .min(NOTEBASE_COLUMN_MIN_WIDTH)
+  .max(NOTEBASE_COLUMN_MAX_WIDTH);
 
 export const notebaseColumnSchema = z.object({
   id: z.string(),
@@ -14,63 +23,68 @@ export const notebaseColumnSchema = z.object({
   wrap: z.boolean(),
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
-})
-export type NotebaseColumn = z.infer<typeof notebaseColumnSchema>
+});
+export type NotebaseColumn = z.infer<typeof notebaseColumnSchema>;
 
-export const notebaseColumnCreateDataSchema = z.object({
-  id: z.uuid().optional(),
-  name: z.string().min(1),
-  config: notebaseColumnConfigSchema,
-}).strict()
-export type NotebaseColumnCreateData = z.infer<typeof notebaseColumnCreateDataSchema>
+export const notebaseColumnCreateDataSchema = z
+  .object({
+    id: z.uuid().optional(),
+    name: z.string().min(1),
+    config: notebaseColumnConfigSchema,
+  })
+  .strict();
+export type NotebaseColumnCreateData = z.infer<typeof notebaseColumnCreateDataSchema>;
 
-export const notebaseColumnUpdateDataSchema = z.object({
-  name: z.string().min(1).optional(),
-  config: notebaseColumnConfigSchema.optional(),
-  width: notebaseColumnWidthSchema.nullable().optional(),
-  wrap: z.boolean().optional(),
-}).strict()
-export type NotebaseColumnUpdateData = z.infer<typeof notebaseColumnUpdateDataSchema>
+export const notebaseColumnUpdateDataSchema = z
+  .object({
+    expectedUpdatedAt: expectedUpdatedAtSchema.optional(),
+    name: z.string().min(1).optional(),
+    config: notebaseColumnConfigSchema.optional(),
+    width: notebaseColumnWidthSchema.nullable().optional(),
+    wrap: z.boolean().optional(),
+  })
+  .strict();
+export type NotebaseColumnUpdateData = z.infer<typeof notebaseColumnUpdateDataSchema>;
 
 export const NotebaseColumnCreateInputSchema = z.object({
   notebaseId: z.uuid(),
   data: notebaseColumnCreateDataSchema,
-})
-export type NotebaseColumnCreateInput = z.infer<typeof NotebaseColumnCreateInputSchema>
+});
+export type NotebaseColumnCreateInput = z.infer<typeof NotebaseColumnCreateInputSchema>;
 
 export const NotebaseColumnCreateOutputSchema = z.object({
+  field: notebaseColumnSchema,
   txid: z.number(),
-})
-export type NotebaseColumnCreateOutput = z.infer<typeof NotebaseColumnCreateOutputSchema>
+});
+export type NotebaseColumnCreateOutput = z.infer<typeof NotebaseColumnCreateOutputSchema>;
 
 export const NotebaseColumnUpdateInputSchema = z.object({
   notebaseColumnId: z.uuid(),
   data: notebaseColumnUpdateDataSchema,
-})
-export type NotebaseColumnUpdateInput = z.infer<typeof NotebaseColumnUpdateInputSchema>
+});
+export type NotebaseColumnUpdateInput = z.infer<typeof NotebaseColumnUpdateInputSchema>;
 
 export const NotebaseColumnUpdateOutputSchema = z.object({
+  field: notebaseColumnSchema,
   txid: z.number(),
-})
-export type NotebaseColumnUpdateOutput = z.infer<typeof NotebaseColumnUpdateOutputSchema>
+});
+export type NotebaseColumnUpdateOutput = z.infer<typeof NotebaseColumnUpdateOutputSchema>;
 
 export const NotebaseColumnDeleteInputSchema = z.object({
   notebaseColumnId: z.uuid(),
-})
-export type NotebaseColumnDeleteInput = z.infer<typeof NotebaseColumnDeleteInputSchema>
+});
+export type NotebaseColumnDeleteInput = z.infer<typeof NotebaseColumnDeleteInputSchema>;
 
-export const NotebaseColumnDeleteOutputSchema = z.object({
-  txid: z.number(),
-})
-export type NotebaseColumnDeleteOutput = z.infer<typeof NotebaseColumnDeleteOutputSchema>
+export const NotebaseColumnDeleteOutputSchema = deletionResultSchema;
+export type NotebaseColumnDeleteOutput = z.infer<typeof NotebaseColumnDeleteOutputSchema>;
 
 export const NotebaseColumnReorderInputSchema = z.object({
   notebaseId: z.uuid(),
   ids: z.array(z.uuid()),
-})
-export type NotebaseColumnReorderInput = z.infer<typeof NotebaseColumnReorderInputSchema>
+});
+export type NotebaseColumnReorderInput = z.infer<typeof NotebaseColumnReorderInputSchema>;
 
 export const NotebaseColumnReorderOutputSchema = z.object({
   txid: z.number(),
-})
-export type NotebaseColumnReorderOutput = z.infer<typeof NotebaseColumnReorderOutputSchema>
+});
+export type NotebaseColumnReorderOutput = z.infer<typeof NotebaseColumnReorderOutputSchema>;

package/src/schemas/notebase-row.ts

@@ -1,6 +1,8 @@
-import { z } from "zod"
+import { paginationShape, pageSchema } from "./pagination";
+import { deletionResultSchema, expectedUpdatedAtSchema } from "./resource-mutation";
+import { z } from "zod";
 
-export const notebaseRowCellsSchema = z.record(z.string(), z.unknown())
+export const notebaseRowCellsSchema = z.record(z.string(), z.unknown());
 
 export const notebaseRowSchema = z.object({
   id: z.string(),
@@ -9,68 +11,77 @@ export const notebaseRowSchema = z.object({
   position: z.number(),
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
-})
-export type NotebaseRow = z.infer<typeof notebaseRowSchema>
+});
+export type NotebaseRow = z.infer<typeof notebaseRowSchema>;
 
-export const notebaseRowCreateDataSchema = z.object({
-  id: z.uuid().optional(),
-  cells: notebaseRowCellsSchema.optional(),
-}).strict()
-export type NotebaseRowCreateData = z.infer<typeof notebaseRowCreateDataSchema>
+export const notebaseRowCreateDataSchema = z
+  .object({
+    id: z.uuid().optional(),
+    cells: notebaseRowCellsSchema.optional(),
+  })
+  .strict();
+export type NotebaseRowCreateData = z.infer<typeof notebaseRowCreateDataSchema>;
 
-export const notebaseRowUpdateDataSchema = z.object({
-  cells: notebaseRowCellsSchema.optional(),
-}).strict()
-export type NotebaseRowUpdateData = z.infer<typeof notebaseRowUpdateDataSchema>
+export const notebaseRowUpdateDataSchema = z
+  .object({
+    cells: notebaseRowCellsSchema.optional(),
+    expectedUpdatedAt: expectedUpdatedAtSchema.optional(),
+  })
+  .strict();
+export type NotebaseRowUpdateData = z.infer<typeof notebaseRowUpdateDataSchema>;
 
 export const NotebaseRowCreateInputSchema = z.object({
   notebaseId: z.uuid(),
   data: notebaseRowCreateDataSchema,
-})
-export type NotebaseRowCreateInput = z.infer<typeof NotebaseRowCreateInputSchema>
+});
+export type NotebaseRowCreateInput = z.infer<typeof NotebaseRowCreateInputSchema>;
 
 export const NotebaseRowCreateOutputSchema = z.object({
+  note: notebaseRowSchema,
   txid: z.number(),
-})
-export type NotebaseRowCreateOutput = z.infer<typeof NotebaseRowCreateOutputSchema>
+});
+export type NotebaseRowCreateOutput = z.infer<typeof NotebaseRowCreateOutputSchema>;
 
-export const NOTEBASE_ROW_CREATE_MANY_MAX_ROWS = 50
+export const NOTEBASE_ROW_CREATE_MANY_MAX_ROWS = 50;
 
-export const NotebaseRowCreateManyInputSchema = z.object({
-  notebaseId: z.uuid(),
-  rows: z.array(notebaseRowCreateDataSchema).min(1).max(NOTEBASE_ROW_CREATE_MANY_MAX_ROWS),
-}).superRefine((input, ctx) => {
-  const seenIds = new Set<string>()
-
-  input.rows.forEach((row, index) => {
-    if (row.id === undefined) {
-      return
-    }
-
-    if (seenIds.has(row.id)) {
-      ctx.addIssue({
-        code: "custom",
-        message: `Duplicate row id "${row.id}".`,
-        path: ["rows", index, "id"],
-      })
-      return
-    }
-
-    seenIds.add(row.id)
+export const NotebaseRowCreateManyInputSchema = z
+  .object({
+    notebaseId: z.uuid(),
+    rows: z.array(notebaseRowCreateDataSchema).min(1).max(NOTEBASE_ROW_CREATE_MANY_MAX_ROWS),
   })
-})
-export type NotebaseRowCreateManyInput = z.infer<typeof NotebaseRowCreateManyInputSchema>
+  .superRefine((input, ctx) => {
+    const seenIds = new Set<string>();
+
+    input.rows.forEach((row, index) => {
+      if (row.id === undefined) {
+        return;
+      }
+
+      if (seenIds.has(row.id)) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Duplicate row id "${row.id}".`,
+          path: ["rows", index, "id"],
+        });
+        return;
+      }
+
+      seenIds.add(row.id);
+    });
+  });
+export type NotebaseRowCreateManyInput = z.infer<typeof NotebaseRowCreateManyInputSchema>;
 
 export const NotebaseRowCreateManyOutputSchema = z.object({
+  items: z.array(notebaseRowSchema),
   txid: z.number(),
-})
-export type NotebaseRowCreateManyOutput = z.infer<typeof NotebaseRowCreateManyOutputSchema>
+});
+export type NotebaseRowCreateManyOutput = z.infer<typeof NotebaseRowCreateManyOutputSchema>;
 
 export const NotebaseRowUpdateInputSchema = z.object({
   notebaseRowId: z.uuid(),
   data: notebaseRowUpdateDataSchema,
-})
-export type NotebaseRowUpdateInput = z.infer<typeof NotebaseRowUpdateInputSchema>
+});
+export type NotebaseRowUpdateInput = z.infer<typeof NotebaseRowUpdateInputSchema>;
 
 export const NotebaseRowUpdateOutputSchema = z.object({
   id: z.uuid(),
@@ -80,26 +91,46 @@ export const NotebaseRowUpdateOutputSchema = z.object({
   createdAt: z.date(),
   updatedAt: z.date(),
   txid: z.number(),
-})
-export type NotebaseRowUpdateOutput = z.infer<typeof NotebaseRowUpdateOutputSchema>
+});
+export type NotebaseRowUpdateOutput = z.infer<typeof NotebaseRowUpdateOutputSchema>;
 
 export const NotebaseRowDeleteInputSchema = z.object({
   notebaseRowId: z.uuid(),
-})
-export type NotebaseRowDeleteInput = z.infer<typeof NotebaseRowDeleteInputSchema>
+});
+export type NotebaseRowDeleteInput = z.infer<typeof NotebaseRowDeleteInputSchema>;
 
-export const NotebaseRowDeleteOutputSchema = z.object({
-  txid: z.number(),
-})
-export type NotebaseRowDeleteOutput = z.infer<typeof NotebaseRowDeleteOutputSchema>
+export const NotebaseRowDeleteOutputSchema = deletionResultSchema;
+export type NotebaseRowDeleteOutput = z.infer<typeof NotebaseRowDeleteOutputSchema>;
 
 export const NotebaseRowReorderInputSchema = z.object({
   notebaseId: z.uuid(),
   ids: z.array(z.uuid()),
-})
-export type NotebaseRowReorderInput = z.infer<typeof NotebaseRowReorderInputSchema>
+});
+export type NotebaseRowReorderInput = z.infer<typeof NotebaseRowReorderInputSchema>;
 
 export const NotebaseRowReorderOutputSchema = z.object({
   txid: z.number(),
-})
-export type NotebaseRowReorderOutput = z.infer<typeof NotebaseRowReorderOutputSchema>
+});
+export type NotebaseRowReorderOutput = z.infer<typeof NotebaseRowReorderOutputSchema>;
+
+export const NotebaseRowListInputSchema = z
+  .object({
+    notebaseId: z.uuid().optional(),
+    // Two characters is already a meaningful CJK query; one matches nearly
+    // every note while costing the same full scan, so the floor is a cost
+    // control rather than an ergonomic preference.
+    query: z.string().trim().min(2).max(200).optional(),
+    ...paginationShape,
+  })
+  // Listing without a notebase is a plain indexed read. Searching is not: it
+  // expands every candidate row's cells and cannot use an index, so it stays
+  // scoped to one notebase, where `notebase_rows_notebase_id_idx` bounds the
+  // candidate set. Searching everything means iterating over notebases.
+  .refine((input) => input.query === undefined || input.notebaseId !== undefined, {
+    error: "notebaseId is required when query is set",
+    path: ["notebaseId"],
+  });
+export type NotebaseRowListInput = z.infer<typeof NotebaseRowListInputSchema>;
+export const NotebaseRowListOutputSchema = pageSchema(notebaseRowSchema);
+export const NotebaseRowGetInputSchema = z.object({ id: z.uuid() });
+export const NotebaseRowGetOutputSchema = notebaseRowSchema;

package/src/schemas/notebase-stats.ts

@@ -1,24 +1,32 @@
-import { z } from "zod"
+import { z } from "zod";
 
-export const notebaseActivityStatsItemSchema = z.object({
-  date: z.iso.date(),
-  notes: z.number().int().nonnegative(),
-}).strict()
-export type NotebaseActivityStatsItem = z.infer<typeof notebaseActivityStatsItemSchema>
+export const notebaseActivityStatsItemSchema = z
+  .object({
+    date: z.iso.date(),
+    notes: z.number().int().nonnegative(),
+  })
+  .strict();
+export type NotebaseActivityStatsItem = z.infer<typeof notebaseActivityStatsItemSchema>;
 
-export const notebaseActivityStatsOutputSchema = z.object({
-  daily: z.array(notebaseActivityStatsItemSchema),
-}).strict()
-export type NotebaseActivityStatsOutput = z.infer<typeof notebaseActivityStatsOutputSchema>
+export const notebaseActivityStatsOutputSchema = z
+  .object({
+    daily: z.array(notebaseActivityStatsItemSchema),
+  })
+  .strict();
+export type NotebaseActivityStatsOutput = z.infer<typeof notebaseActivityStatsOutputSchema>;
 
-export const notebaseRowGrowthStatsItemSchema = z.object({
-  date: z.iso.date(),
-  delta: z.number().int(),
-}).strict()
-export type NotebaseRowGrowthStatsItem = z.infer<typeof notebaseRowGrowthStatsItemSchema>
+export const notebaseRowGrowthStatsItemSchema = z
+  .object({
+    date: z.iso.date(),
+    delta: z.number().int(),
+  })
+  .strict();
+export type NotebaseRowGrowthStatsItem = z.infer<typeof notebaseRowGrowthStatsItemSchema>;
 
-export const notebaseRowGrowthStatsOutputSchema = z.object({
-  baseTotal: z.number().int().nonnegative(),
-  daily: z.array(notebaseRowGrowthStatsItemSchema),
-}).strict()
-export type NotebaseRowGrowthStatsOutput = z.infer<typeof notebaseRowGrowthStatsOutputSchema>
+export const notebaseRowGrowthStatsOutputSchema = z
+  .object({
+    baseTotal: z.number().int().nonnegative(),
+    daily: z.array(notebaseRowGrowthStatsItemSchema),
+  })
+  .strict();
+export type NotebaseRowGrowthStatsOutput = z.infer<typeof notebaseRowGrowthStatsOutputSchema>;

package/src/schemas/notebase-view.ts

@@ -1,50 +1,60 @@
-import { z } from "zod"
-
-export const notebaseViewTypeSchema = z.enum(["table", "kanban", "gallery"])
-export type NotebaseViewType = z.infer<typeof notebaseViewTypeSchema>
-
-export const notebaseViewConfigSchema = z.object({
-  notebaseColumnWidths: z.record(z.string(), z.number()).optional(),
-  hiddenNotebaseColumns: z.array(z.string()).optional(),
-  groupByNotebaseColumnId: z.string().optional(),
-}).catchall(z.unknown())
-export type NotebaseViewConfig = z.infer<typeof notebaseViewConfigSchema>
-
-export const notebaseViewFilterSchema = z.object({
-  notebaseColumnId: z.string(),
-  operator: z.string(),
-  value: z.unknown(),
-}).strict()
-export type NotebaseViewFilter = z.infer<typeof notebaseViewFilterSchema>
-
-export const notebaseViewFiltersSchema = z.array(notebaseViewFilterSchema)
-
-export const notebaseViewSortSchema = z.object({
-  notebaseColumnId: z.string(),
-  direction: z.enum(["asc", "desc"]),
-}).strict()
-export type NotebaseViewSort = z.infer<typeof notebaseViewSortSchema>
-
-export const notebaseViewSortsSchema = z.array(notebaseViewSortSchema)
-
-export const notebaseViewCreateDataSchema = z.object({
-  id: z.uuid().optional(),
-  name: z.string().min(1),
-  type: notebaseViewTypeSchema,
-  config: notebaseViewConfigSchema.optional(),
-  filters: notebaseViewFiltersSchema.optional(),
-  sorts: notebaseViewSortsSchema.optional(),
-}).strict()
-export type NotebaseViewCreateData = z.infer<typeof notebaseViewCreateDataSchema>
-
-export const notebaseViewUpdateDataSchema = z.object({
-  name: z.string().min(1).optional(),
-  type: notebaseViewTypeSchema.optional(),
-  config: notebaseViewConfigSchema.optional(),
-  filters: notebaseViewFiltersSchema.optional(),
-  sorts: notebaseViewSortsSchema.optional(),
-}).strict()
-export type NotebaseViewUpdateData = z.infer<typeof notebaseViewUpdateDataSchema>
+import { z } from "zod";
+
+export const notebaseViewTypeSchema = z.enum(["table", "kanban", "gallery"]);
+export type NotebaseViewType = z.infer<typeof notebaseViewTypeSchema>;
+
+export const notebaseViewConfigSchema = z
+  .object({
+    notebaseColumnWidths: z.record(z.string(), z.number()).optional(),
+    hiddenNotebaseColumns: z.array(z.string()).optional(),
+    groupByNotebaseColumnId: z.string().optional(),
+  })
+  .catchall(z.unknown());
+export type NotebaseViewConfig = z.infer<typeof notebaseViewConfigSchema>;
+
+export const notebaseViewFilterSchema = z
+  .object({
+    notebaseColumnId: z.string(),
+    operator: z.string(),
+    value: z.unknown(),
+  })
+  .strict();
+export type NotebaseViewFilter = z.infer<typeof notebaseViewFilterSchema>;
+
+export const notebaseViewFiltersSchema = z.array(notebaseViewFilterSchema);
+
+export const notebaseViewSortSchema = z
+  .object({
+    notebaseColumnId: z.string(),
+    direction: z.enum(["asc", "desc"]),
+  })
+  .strict();
+export type NotebaseViewSort = z.infer<typeof notebaseViewSortSchema>;
+
+export const notebaseViewSortsSchema = z.array(notebaseViewSortSchema);
+
+export const notebaseViewCreateDataSchema = z
+  .object({
+    id: z.uuid().optional(),
+    name: z.string().min(1),
+    type: notebaseViewTypeSchema,
+    config: notebaseViewConfigSchema.optional(),
+    filters: notebaseViewFiltersSchema.optional(),
+    sorts: notebaseViewSortsSchema.optional(),
+  })
+  .strict();
+export type NotebaseViewCreateData = z.infer<typeof notebaseViewCreateDataSchema>;
+
+export const notebaseViewUpdateDataSchema = z
+  .object({
+    name: z.string().min(1).optional(),
+    type: notebaseViewTypeSchema.optional(),
+    config: notebaseViewConfigSchema.optional(),
+    filters: notebaseViewFiltersSchema.optional(),
+    sorts: notebaseViewSortsSchema.optional(),
+  })
+  .strict();
+export type NotebaseViewUpdateData = z.infer<typeof notebaseViewUpdateDataSchema>;
 
 export const notebaseViewSchema = z.object({
   id: z.string(),
@@ -57,5 +67,5 @@ export const notebaseViewSchema = z.object({
   position: z.number(),
   createdAt: z.coerce.date(),
   updatedAt: z.coerce.date(),
-})
-export type NotebaseView = z.infer<typeof notebaseViewSchema>
+});
+export type NotebaseView = z.infer<typeof notebaseViewSchema>;