ocean-brain 0.5.0 → 0.6.0

package/server/dist/features/view/services/workspace.js

@@ -1,9 +1,20 @@
+import {
+  InvalidNotePropertyInputError,
+  normalizePropertyKey,
+  normalizeUrlValue
+} from "../../../features/note/services/properties.js";
 import { buildNoteTagNamesWhere } from "../../../features/note/services/tag-filter.js";
 import models from "../../../models.js";
 const VIEW_WORKSPACE_ID = 1;
 const DEFAULT_VIEW_SECTION_LIMIT = 5;
 const MIN_VIEW_SECTION_LIMIT = 1;
 const MAX_VIEW_SECTION_LIMIT = 20;
+const DEFAULT_VIEW_NOTES_QUERY_LIMIT = 20;
+const MAX_VIEW_NOTES_QUERY_LIMIT = 50;
+const MAX_VIEW_PROPERTY_FILTERS = 10;
+const DEFAULT_VIEW_DISPLAY_TYPE = "list";
+const DEFAULT_VIEW_SORT_BY = "updatedAt";
+const DEFAULT_VIEW_SORT_ORDER = "desc";
 const orderedViewSectionTagsInclude = {
   tags: {
     orderBy: [{ order: "asc" }, { createdAt: "asc" }]
@@ -32,6 +43,116 @@ const normalizeViewTagNames = (values) => {
   const normalizedTagNames = values.flatMap((value) => value.split(","));
   return Array.from(new Set(normalizedTagNames.map(normalizeTagName).filter(Boolean)));
 };
+const isViewPropertyFilterOperator = (value) => {
+  return value === "equals" || value === "before" || value === "after" || value === "exists" || value === "notExists";
+};
+const isPropertyValueType = (value) => {
+  return value === "text" || value === "url" || value === "number" || value === "date" || value === "boolean" || value === "select";
+};
+const normalizeViewDisplayType = (value) => {
+  return value === "calendar" ? "calendar" : DEFAULT_VIEW_DISPLAY_TYPE;
+};
+const normalizeViewSortBy = (value) => {
+  return value === "createdAt" || value === "title" ? value : DEFAULT_VIEW_SORT_BY;
+};
+const normalizeViewSortOrder = (value) => {
+  return value === "asc" ? "asc" : DEFAULT_VIEW_SORT_ORDER;
+};
+const normalizeFilterValue = ({
+  value,
+  valueType,
+  operator
+}) => {
+  if (operator === "exists" || operator === "notExists") {
+    return null;
+  }
+  const normalizedValue = String(value ?? "").trim();
+  if (!normalizedValue) {
+    throw new InvalidNotePropertyInputError("Property filter value is required.");
+  }
+  if (valueType === "number" && !Number.isFinite(Number(normalizedValue))) {
+    throw new InvalidNotePropertyInputError("Number property filter value must be finite.");
+  }
+  if (valueType === "boolean" && normalizedValue !== "true" && normalizedValue !== "false") {
+    throw new InvalidNotePropertyInputError("Boolean property filter value must be true or false.");
+  }
+  if (valueType === "date") {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(normalizedValue)) {
+      throw new InvalidNotePropertyInputError("Date property filter values must use YYYY-MM-DD.");
+    }
+    const date = /* @__PURE__ */ new Date(`${normalizedValue}T00:00:00.000Z`);
+    if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== normalizedValue) {
+      throw new InvalidNotePropertyInputError("Date property filter value is invalid.");
+    }
+  }
+  if ((operator === "before" || operator === "after") && valueType !== "date" && valueType !== "number") {
+    throw new InvalidNotePropertyInputError("Before and after filters require date or number properties.");
+  }
+  if (valueType === "url") {
+    return normalizeUrlValue(normalizedValue);
+  }
+  return normalizedValue;
+};
+const normalizeViewPropertyFilters = (filters) => {
+  const normalizedFilters = filters ?? [];
+  if (normalizedFilters.length > MAX_VIEW_PROPERTY_FILTERS) {
+    throw new InvalidNotePropertyInputError(`A view can have up to ${MAX_VIEW_PROPERTY_FILTERS} property filters.`);
+  }
+  return normalizedFilters.map((filter) => {
+    const key = normalizePropertyKey(filter.key);
+    const valueType = filter.valueType;
+    const operator = filter.operator;
+    if (!isPropertyValueType(valueType)) {
+      throw new InvalidNotePropertyInputError("Property filter value type is required.");
+    }
+    if (!isViewPropertyFilterOperator(operator)) {
+      throw new InvalidNotePropertyInputError("Property filter operator is invalid.");
+    }
+    const storedName = filter.name;
+    const name = typeof storedName === "string" && storedName.trim() ? storedName.trim() : key;
+    return {
+      key,
+      name,
+      valueType,
+      operator,
+      value: normalizeFilterValue({
+        value: filter.value,
+        valueType,
+        operator
+      })
+    };
+  }).filter((filter) => filter !== null);
+};
+const parseStoredViewQuery = (value) => {
+  if (!value) {
+    return {
+      propertyFilters: [],
+      sortBy: DEFAULT_VIEW_SORT_BY,
+      sortOrder: DEFAULT_VIEW_SORT_ORDER
+    };
+  }
+  try {
+    const parsed = JSON.parse(value);
+    return {
+      propertyFilters: normalizeViewPropertyFilters(parsed.propertyFilters ?? []),
+      sortBy: normalizeViewSortBy(parsed.sortBy),
+      sortOrder: normalizeViewSortOrder(parsed.sortOrder)
+    };
+  } catch {
+    return {
+      propertyFilters: [],
+      sortBy: DEFAULT_VIEW_SORT_BY,
+      sortOrder: DEFAULT_VIEW_SORT_ORDER
+    };
+  }
+};
+const serializeStoredViewQuery = ({ propertyFilters, sortBy, sortOrder }) => {
+  return JSON.stringify({
+    propertyFilters,
+    sortBy,
+    sortOrder
+  });
+};
 const clampViewSectionLimit = (value) => {
   const numericValue = typeof value === "number" ? value : Number.NaN;
   if (!Number.isInteger(numericValue)) {
@@ -43,25 +164,48 @@ const normalizeViewTabTitle = (title) => {
   const trimmedTitle = title.trim();
   return trimmedTitle || "Untitled View";
 };
-const buildDefaultSectionTitle = (tagNames) => {
-  if (tagNames.length === 0) {
-    return "Tagged notes";
+const buildDefaultSectionTitle = (tagNames, propertyFilters) => {
+  if (tagNames.length > 0) {
+    return tagNames.slice(0, 2).join(" + ");
   }
-  return tagNames.slice(0, 2).join(" + ");
+  if (propertyFilters.length > 0) {
+    return propertyFilters.slice(0, 2).map((filter) => filter.name).join(" + ");
+  }
+  return "All notes";
 };
 const normalizeViewSectionInput = (input) => {
-  const tagNames = normalizeViewTagNames(input.tagNames);
-  if (tagNames.length === 0) {
-    throw new Error("A view section requires at least one tag.");
-  }
+  const tagNames = normalizeViewTagNames(input.tagNames ?? []);
+  const propertyFilters = normalizeViewPropertyFilters(input.propertyFilters);
   const trimmedTitle = input.title?.trim() ?? "";
+  const sortBy = normalizeViewSortBy(input.sortBy);
+  const sortOrder = normalizeViewSortOrder(input.sortOrder);
   return {
-    title: trimmedTitle || buildDefaultSectionTitle(tagNames),
+    title: trimmedTitle || buildDefaultSectionTitle(tagNames, propertyFilters),
+    displayType: normalizeViewDisplayType(input.displayType),
     tagNames,
     mode: input.mode === "or" ? "or" : "and",
+    propertyFilters,
+    sortBy,
+    sortOrder,
     limit: clampViewSectionLimit(input.limit)
   };
 };
+const normalizeViewNotesQueryInput = (input) => {
+  return {
+    tagNames: normalizeViewTagNames(input.tagNames ?? []),
+    mode: input.mode === "or" ? "or" : "and",
+    propertyFilters: normalizeViewPropertyFilters(input.propertyFilters),
+    sortBy: normalizeViewSortBy(input.sortBy),
+    sortOrder: normalizeViewSortOrder(input.sortOrder)
+  };
+};
+const normalizeViewNotesPagination = (pagination) => {
+  const numericLimit = Number(pagination?.limit ?? DEFAULT_VIEW_NOTES_QUERY_LIMIT);
+  const limit = Number.isInteger(numericLimit) ? Math.min(MAX_VIEW_NOTES_QUERY_LIMIT, Math.max(1, numericLimit)) : DEFAULT_VIEW_NOTES_QUERY_LIMIT;
+  const numericOffset = Number(pagination?.offset ?? 0);
+  const offset = Number.isInteger(numericOffset) ? Math.max(0, numericOffset) : 0;
+  return { limit, offset };
+};
 const pickNextActiveViewTabId = (tabIds, deletedTabId, currentActiveTabId) => {
   const remainingTabIds = tabIds.filter((tabId) => tabId !== deletedTabId);
   if (remainingTabIds.length === 0) {
@@ -94,15 +238,22 @@ const parseViewId = (id) => {
   }
   return numericId;
 };
-const serializeViewSection = (section) => ({
-  id: String(section.id),
-  tabId: String(section.tabId),
-  title: section.title,
-  tagNames: section.tags.map((tag) => tag.name),
-  mode: section.mode,
-  limit: section.limit,
-  order: section.order
-});
+const serializeViewSection = (section) => {
+  const query = parseStoredViewQuery(section.query);
+  return {
+    id: String(section.id),
+    tabId: String(section.tabId),
+    title: section.title,
+    displayType: normalizeViewDisplayType(section.displayType),
+    tagNames: section.tags.map((tag) => tag.name),
+    mode: section.mode,
+    propertyFilters: query.propertyFilters,
+    sortBy: query.sortBy,
+    sortOrder: query.sortOrder,
+    limit: section.limit,
+    order: section.order
+  };
+};
 const serializeViewTab = (tab) => ({
   id: String(tab.id),
   title: tab.title,
@@ -137,6 +288,52 @@ const readViewSection = async (db, id) => {
   });
   return section ? serializeViewSection(section) : null;
 };
+const hydratePropertyFilters = async (db, filters, options = {}) => {
+  if (filters.length === 0) {
+    return [];
+  }
+  const definitions = await db.propertyDefinition.findMany({
+    where: { key: { in: filters.map((filter) => filter.key) } },
+    select: {
+      key: true,
+      name: true,
+      valueType: true,
+      options: {
+        select: {
+          value: true
+        }
+      }
+    }
+  });
+  const definitionByKey = new Map(definitions.map((definition) => [definition.key, definition]));
+  return filters.map((filter) => {
+    const definition = definitionByKey.get(filter.key);
+    if (!definition) {
+      throw new InvalidNotePropertyInputError(`Property ${filter.key} is not defined.`);
+    }
+    if (definition.valueType !== filter.valueType) {
+      throw new InvalidNotePropertyInputError(`Property ${filter.key} uses ${definition.valueType} values.`);
+    }
+    if (options.validateSelectOptions && filter.valueType === "select" && filter.operator !== "exists" && filter.operator !== "notExists") {
+      const optionValue = normalizeSelectFilterValue(filter.value ?? "");
+      if (!definition.options.some((option) => option.value === optionValue)) {
+        throw new InvalidNotePropertyInputError(`Property ${filter.key} option ${optionValue} is not defined.`);
+      }
+    }
+    return {
+      ...filter,
+      name: definition.name
+    };
+  });
+};
+const buildStoredViewQuery = async (db, section) => {
+  const propertyFilters = await hydratePropertyFilters(db, section.propertyFilters, { validateSelectOptions: true });
+  return serializeStoredViewQuery({
+    propertyFilters,
+    sortBy: section.sortBy,
+    sortOrder: section.sortOrder
+  });
+};
 const getNextTabOrder = async (db) => {
   const lastTab = await db.viewTab.findFirst({
     orderBy: [{ order: "desc" }, { createdAt: "desc" }],
@@ -187,6 +384,94 @@ const getViewWorkspace = async () => {
 const getViewSectionById = async (id) => {
   return readViewSection(models, parseViewId(id));
 };
+const normalizeSelectFilterValue = (value) => {
+  return value.trim().toLowerCase().replace(/\s+/g, "-");
+};
+const buildPropertyFilterValueWhere = (filter) => {
+  switch (filter.valueType) {
+    case "number": {
+      const numberValue = Number(filter.value);
+      if (filter.operator === "before") {
+        return { numberValue: { lt: numberValue } };
+      }
+      if (filter.operator === "after") {
+        return { numberValue: { gt: numberValue } };
+      }
+      return { numberValue };
+    }
+    case "date": {
+      const dateValue = /* @__PURE__ */ new Date(`${filter.value}T00:00:00.000Z`);
+      if (filter.operator === "before") {
+        return { dateValue: { lt: dateValue } };
+      }
+      if (filter.operator === "after") {
+        return { dateValue: { gt: dateValue } };
+      }
+      return { dateValue };
+    }
+    case "boolean":
+      return { boolValue: filter.value === "true" };
+    case "select":
+      return { option: { is: { value: normalizeSelectFilterValue(filter.value ?? "") } } };
+    case "url":
+    case "text":
+    default:
+      return { textValueNormalized: filter.value?.toLowerCase() ?? "" };
+  }
+};
+const buildPropertyFilterWhere = (filter) => {
+  const definitionWhere = {
+    definition: {
+      is: {
+        key: filter.key
+      }
+    }
+  };
+  if (filter.operator === "notExists") {
+    return {
+      properties: {
+        none: definitionWhere
+      }
+    };
+  }
+  if (filter.operator === "exists") {
+    return {
+      properties: {
+        some: definitionWhere
+      }
+    };
+  }
+  return {
+    properties: {
+      some: {
+        ...definitionWhere,
+        ...buildPropertyFilterValueWhere(filter)
+      }
+    }
+  };
+};
+const buildViewNotesWhere = (query) => {
+  const clauses = [];
+  if (query.tagNames.length > 0) {
+    clauses.push(buildNoteTagNamesWhere(query.tagNames, query.mode));
+  }
+  for (const filter of query.propertyFilters) {
+    clauses.push(buildPropertyFilterWhere(filter));
+  }
+  if (clauses.length === 0) {
+    return {};
+  }
+  return { AND: clauses };
+};
+const buildViewSectionWhere = (section) => {
+  return buildViewNotesWhere(section);
+};
+const buildViewNotesOrderBy = (query) => {
+  return [{ [query.sortBy]: query.sortOrder }, { id: "asc" }];
+};
+const buildViewSectionOrderBy = (section) => {
+  return buildViewNotesOrderBy(section);
+};
 const getViewSectionNotes = async (id, pagination) => {
   const section = await models.viewSection.findUnique({
     where: { id: parseViewId(id) },
@@ -195,18 +480,12 @@ const getViewSectionNotes = async (id, pagination) => {
   if (!section) {
     return null;
   }
-  const tagNames = section.tags.map((tag) => tag.name);
-  if (tagNames.length === 0) {
-    return {
-      totalCount: 0,
-      notes: []
-    };
-  }
-  const where = buildNoteTagNamesWhere(tagNames, section.mode);
+  const serializedSection = serializeViewSection(section);
+  const where = buildViewSectionWhere(serializedSection);
   const [totalCount, notes] = await Promise.all([
     models.note.count({ where }),
     models.note.findMany({
-      orderBy: { updatedAt: "desc" },
+      orderBy: buildViewSectionOrderBy(serializedSection),
       where,
       take: Number(pagination.limit),
       skip: Number(pagination.offset)
@@ -217,6 +496,33 @@ const getViewSectionNotes = async (id, pagination) => {
     notes
   };
 };
+const getNotesByProperties = async (input, pagination) => {
+  const normalizedQuery = normalizeViewNotesQueryInput(input);
+  if (normalizedQuery.propertyFilters.length === 0) {
+    throw new InvalidNotePropertyInputError("At least one property filter is required.");
+  }
+  const query = {
+    ...normalizedQuery,
+    propertyFilters: await hydratePropertyFilters(models, normalizedQuery.propertyFilters, {
+      validateSelectOptions: true
+    })
+  };
+  const normalizedPagination = normalizeViewNotesPagination(pagination);
+  const where = buildViewNotesWhere(query);
+  const [totalCount, notes] = await Promise.all([
+    models.note.count({ where }),
+    models.note.findMany({
+      orderBy: buildViewNotesOrderBy(query),
+      where,
+      take: normalizedPagination.limit,
+      skip: normalizedPagination.offset
+    })
+  ]);
+  return {
+    totalCount,
+    notes
+  };
+};
 const createViewTab = async (title) => {
   return models.$transaction(async (tx) => {
     const workspace = await ensureViewWorkspace(tx);
@@ -323,10 +629,13 @@ const createViewSection = async (tabId, input) => {
       throw new Error("View tab not found.");
     }
     const nextSectionOrder = await getNextSectionOrder(tx, numericTabId);
+    const query = await buildStoredViewQuery(tx, nextSection);
     const createdSection = await tx.viewSection.create({
       data: {
         tabId: numericTabId,
         title: nextSection.title,
+        displayType: nextSection.displayType,
+        query,
         mode: nextSection.mode,
         limit: nextSection.limit,
         order: nextSectionOrder,
@@ -345,23 +654,28 @@ const createViewSection = async (tabId, input) => {
 const updateViewSection = async (id, input) => {
   const sectionId = parseViewId(id);
   const nextSection = normalizeViewSectionInput(input);
-  const updatedSection = await models.viewSection.update({
-    where: { id: sectionId },
-    data: {
-      title: nextSection.title,
-      mode: nextSection.mode,
-      limit: nextSection.limit,
-      tags: {
-        deleteMany: {},
-        create: nextSection.tagNames.map((tagName, index) => ({
-          name: tagName,
-          order: index
-        }))
-      }
-    },
-    include: orderedViewSectionTagsInclude
+  return models.$transaction(async (tx) => {
+    const query = await buildStoredViewQuery(tx, nextSection);
+    const updatedSection = await tx.viewSection.update({
+      where: { id: sectionId },
+      data: {
+        title: nextSection.title,
+        displayType: nextSection.displayType,
+        query,
+        mode: nextSection.mode,
+        limit: nextSection.limit,
+        tags: {
+          deleteMany: {},
+          create: nextSection.tagNames.map((tagName, index) => ({
+            name: tagName,
+            order: index
+          }))
+        }
+      },
+      include: orderedViewSectionTagsInclude
+    });
+    return serializeViewSection(updatedSection);
   });
-  return serializeViewSection(updatedSection);
 };
 const deleteViewSection = async (id) => {
   const sectionId = parseViewId(id);
@@ -408,17 +722,27 @@ const reorderViewSections = async (tabId, sectionIds) => {
   });
 };
 export {
+  DEFAULT_VIEW_NOTES_QUERY_LIMIT,
   DEFAULT_VIEW_SECTION_LIMIT,
+  MAX_VIEW_NOTES_QUERY_LIMIT,
   MAX_VIEW_SECTION_LIMIT,
   MIN_VIEW_SECTION_LIMIT,
+  buildPropertyFilterWhere,
+  buildViewNotesWhere,
+  buildViewSectionWhere,
   clampViewSectionLimit,
   createViewSection,
   createViewTab,
   deleteViewSection,
   deleteViewTab,
+  getNotesByProperties,
   getViewSectionById,
   getViewSectionNotes,
   getViewWorkspace,
+  hydratePropertyFilters,
+  normalizeViewNotesPagination,
+  normalizeViewNotesQueryInput,
+  normalizeViewPropertyFilters,
   normalizeViewSectionInput,
   normalizeViewTabTitle,
   normalizeViewTagNames,