@softr/sdk 0.0.74-alpha.0 → 0.0.75

package/dist/action.d.ts

@@ -234,5 +234,35 @@ type IntegrationDefinition<TId extends string> = {
  * const res = await listEvents({ query: { timeMin: now, singleEvents: "true" } })
  */
 declare function defineIntegration<const TId extends string>(definition: IntegrationDefinition<TId>): IntegrationAction<TId>;
+type CommentsResource = {
+  type: "COMMENTS";
+  datasourceId: SoftrDatasourceId;
+};
+/** Comment threads on the records of one datasource. It has no `permissions`. */
+type CommentsAction<TId extends string = string> = {
+  id: TId;
+  resource: CommentsResource;
+};
+type CommentsDefinition<TId extends string> = {
+  id: TId;
+  datasourceId: SoftrDatasourceId;
+};
+/**
+ * Declares comment threads on the records of a datasource. Each record has one thread.
+ *
+ * Who may read, post and delete comes from the app's comment settings in Softr, not from code. Two
+ * declarations on the same datasource share the same threads.
+ *
+ * Pass the returned object to `comments.*` from `@softr/sdk/server`.
+ *
+ * @example
+ * const orderComments = defineComments({
+ *   id: "orderComments",
+ *   datasourceId: "8f14e45f-ceea-467a-9d0b-2c1a0e3b5d77",
+ * })
+ *
+ * const thread = await comments.list(orderComments, { recordId })
+ */
+declare function defineComments<const TId extends string>(definition: CommentsDefinition<TId>): CommentsAction<TId>;
 //#endregion
-export { ActionData, ActionPermissions, ActionRecord, ActionShape, DatasourceAction, FieldTypeOf, IntegrationAction, ReadOf, ReadShape, SoftrDatasources, WorkflowAction, defineIntegration, defineMutation, defineQuery, defineWorkflow };
+export { ActionData, ActionPermissions, ActionRecord, ActionShape, CommentsAction, DatasourceAction, FieldTypeOf, IntegrationAction, ReadOf, ReadShape, SoftrDatasources, WorkflowAction, defineComments, defineIntegration, defineMutation, defineQuery, defineWorkflow };

package/dist/action.js

@@ -50,6 +50,31 @@ function defineIntegration(definition) {
 		permissions
 	};
 }
+/**
+* Declares comment threads on the records of a datasource. Each record has one thread.
+*
+* Who may read, post and delete comes from the app's comment settings in Softr, not from code. Two
+* declarations on the same datasource share the same threads.
+*
+* Pass the returned object to `comments.*` from `@softr/sdk/server`.
+*
+* @example
+* const orderComments = defineComments({
+*   id: "orderComments",
+*   datasourceId: "8f14e45f-ceea-467a-9d0b-2c1a0e3b5d77",
+* })
+*
+* const thread = await comments.list(orderComments, { recordId })
+*/
+function defineComments(definition) {
+	return {
+		id: definition.id,
+		resource: {
+			type: "COMMENTS",
+			datasourceId: definition.datasourceId
+		}
+	};
+}
 function isDatasourceAction(value) {
 	if (typeof value !== "object" || value === null) return false;
 	const candidate = value;
@@ -58,4 +83,4 @@ function isDatasourceAction(value) {
 }
 
 //#endregion
-export { defineIntegration, defineMutation, defineQuery, defineWorkflow, isDatasourceAction };
+export { defineComments, defineIntegration, defineMutation, defineQuery, defineWorkflow, isDatasourceAction };

package/dist/auth/methods/profile.d.ts

@@ -5,7 +5,7 @@ import { AuthError, Result } from "./utils.js";
 
 /**
  * Changes the signed-in visitor's own name, photo, or both. A field left out
- * stays as it is, and `avatar: null` removes the photo.
+ * stays as it is. {@link removeAvatar} removes the photo.
  *
  * The photo can change only where `user.avatarEditable` is true. Elsewhere a
  * photo answers `avatarNotSupported`, so hide the photo controls instead.
@@ -20,7 +20,16 @@ import { AuthError, Result } from "./utils.js";
  */
 declare function updateProfile(changes: {
   fullName?: string;
-  avatar?: File | null;
+  avatar?: File;
 }): Promise<Result<User, AuthError>>;
+/**
+ * Removes the signed-in visitor's own photo. Like {@link updateProfile}, it
+ * works only where `user.avatarEditable` is true, and answers with the visitor
+ * as they are now.
+ *
+ * @example
+ * const result = await auth.removeAvatar()
+ */
+declare function removeAvatar(): Promise<Result<User, AuthError>>;
 //#endregion
-export { updateProfile };
+export { removeAvatar, updateProfile };

package/dist/auth/methods/profile.js

@@ -7,7 +7,7 @@ import { authError } from "./utils.js";
 //#region src/auth/methods/profile.ts
 /**
 * Changes the signed-in visitor's own name, photo, or both. A field left out
-* stays as it is, and `avatar: null` removes the photo.
+* stays as it is. {@link removeAvatar} removes the photo.
 *
 * The photo can change only where `user.avatarEditable` is true. Elsewhere a
 * photo answers `avatarNotSupported`, so hide the photo controls instead.
@@ -26,9 +26,23 @@ async function updateProfile(changes) {
 	if (token === null) return authError("notAuthenticated", "Nobody is signed in.");
 	const form = new FormData();
 	if (changes.fullName !== void 0) form.set("fullName", changes.fullName);
-	if (changes.avatar === null) form.set("removeAvatar", "true");
 	if (changes.avatar) form.set("avatar", changes.avatar);
-	const result = await makePlatform(sessionConfig().applicationId).updateProfile(token, form);
+	return answer(await makePlatform(sessionConfig().applicationId).updateProfile(token, form));
+}
+/**
+* Removes the signed-in visitor's own photo. Like {@link updateProfile}, it
+* works only where `user.avatarEditable` is true, and answers with the visitor
+* as they are now.
+*
+* @example
+* const result = await auth.removeAvatar()
+*/
+async function removeAvatar() {
+	const token = readSessionToken();
+	if (token === null) return authError("notAuthenticated", "Nobody is signed in.");
+	return answer(await makePlatform(sessionConfig().applicationId).removeAvatar(token));
+}
+function answer(result) {
 	if (!result.ok) {
 		switch (result.status) {
 			case 400: return authError("invalidName", result.message);
@@ -49,4 +63,4 @@ async function updateProfile(changes) {
 }
 
 //#endregion
-export { updateProfile };
+export { removeAvatar, updateProfile };

package/dist/auth/platform.js

@@ -272,6 +272,10 @@ function makePlatform(applicationId) {
 			token,
 			form
 		}, userSchema),
+		removeAvatar: (token) => request(`/v1/vibe/applications/${applicationId}/users/me/profile/avatar`, {
+			method: "DELETE",
+			token
+		}, userSchema),
 		signOut: (token) => request(`/v1/applications/${applicationId}/users/sign-out`, {
 			method: "POST",
 			token

package/dist/auth/server.d.ts

@@ -6,7 +6,7 @@ import { checkPasswordLink, requestPasswordReset, setPasswordWithLink } from "./
 import { settings } from "./methods/settings.js";
 import { confirmSignUp, signUp } from "./methods/signup.js";
 import { signInWithGoogle } from "./methods/social.js";
-import { updateProfile } from "./methods/profile.js";
+import { removeAvatar, updateProfile } from "./methods/profile.js";
 import { currentUserRow } from "./current-user-row.js";
 import "@tanstack/react-start/server-only";
 
@@ -36,6 +36,7 @@ declare const auth: {
   removeAuthenticator: typeof removeAuthenticator;
   settings: typeof settings;
   updateProfile: typeof updateProfile;
+  removeAvatar: typeof removeAvatar;
   currentUserRow: typeof currentUserRow;
 };
 //#endregion

package/dist/auth/server.js

@@ -6,7 +6,7 @@ import { signIn, signOut } from "./methods/password.js";
 import { checkPasswordLink, requestPasswordReset, setPasswordWithLink } from "./methods/passwordLink.js";
 import { confirmSignUp, signUp } from "./methods/signup.js";
 import { signInWithGoogle } from "./methods/social.js";
-import { updateProfile } from "./methods/profile.js";
+import { removeAvatar, updateProfile } from "./methods/profile.js";
 import { currentUserRow } from "./current-user-row.js";
 import "@tanstack/react-start/server-only";
 
@@ -35,6 +35,7 @@ const auth = {
 	removeAuthenticator,
 	settings,
 	updateProfile,
+	removeAvatar,
 	currentUserRow
 };
 

package/dist/client.d.ts

@@ -1,3 +1,4 @@
 import { FileItem, useFileUpload } from "./core/use-file-upload.js";
+import { useCommentComposer } from "./comments/use-comment-composer.js";
 import "@tanstack/react-start/client-only";
-export { type FileItem, useFileUpload };
+export { type FileItem, useCommentComposer, useFileUpload };

package/dist/client.js

@@ -1,4 +1,5 @@
 import { useFileUpload } from "./core/use-file-upload.js";
+import { useCommentComposer } from "./comments/use-comment-composer.js";
 import "@tanstack/react-start/client-only";
 
-export { useFileUpload };
+export { useCommentComposer, useFileUpload };

package/dist/codegen/datasource-types.js

@@ -161,7 +161,7 @@ function writeValue(shape, context) {
 		case "UPDATED_AT": return "IsoDateTime";
 		case "TIME": return "IsoTime";
 		case "DATE_RANGE": return "{ from: IsoDate; to: IsoDate }";
-		case "SELECT": return "SelectChoiceInput";
+		case "SELECT": return selectInput(shape.options);
 		case "ATTACHMENT": return "AttachmentInput";
 		case "LINKED_RECORD": return "LinkedRecordInput";
 		case "USER": return "WorkspaceUser";
@@ -208,6 +208,19 @@ function selectValue(options) {
 	if (choices === null) return "SelectChoice";
 	return union(choices.map(({ id, label }) => `{ id: ${quote(id)}; label: ${quote(label)} }`));
 }
+/**
+* A write carries the id alone. The API resolves it against the choice list and writes that
+* choice's own label, so a label sent alongside is dropped.
+*
+* The API also takes `{ label }` with no id, and a label matching nothing creates a choice.
+* The union omits that: it would make every misspelling type-check, and the cost of one is a
+* new choice in the field rather than an error.
+*/
+function selectInput(options) {
+	const choices = choiceEntries(options);
+	if (choices === null) return "SelectChoiceInput";
+	return union(choices.map(({ id }) => `{ id: ${quote(id)} }`));
+}
 function datePrecision(options) {
 	const precision = option(options, "precision");
 	return typeof precision === "string" ? precision : null;

package/dist/comments/comments.d.ts

@@ -0,0 +1,168 @@
+import { CommentsAction } from "../action.js";
+
+//#region src/comments/comments.d.ts
+/** A person picked in the composer, and where their `@name` sits in the text. */
+type CommentMention = {
+  name: string;
+  email: string;
+  start: number;
+  end: number;
+};
+type CommentAttachmentInput = {
+  url: string;
+  filename: string;
+  type?: string | null;
+};
+type CommentView = {
+  id: string;
+  /** The body as safe HTML. Render it with `dangerouslySetInnerHTML`, never as text. */
+  bodyHtml: string;
+  attachments: Array<{
+    url: string;
+    filename: string;
+    type: string | null;
+  }>;
+  author: {
+    name: string;
+    avatar: string | null;
+    isDeactivated: boolean;
+  };
+  /** ISO 8601. */
+  createdAt: string;
+  canDelete: boolean;
+  canEdit: boolean;
+  edited: boolean;
+  /** The body as the visitor typed it, to fill an edit box. `null` unless `canEdit`. */
+  source: {
+    text: string;
+    mentions: Array<CommentMention>;
+  } | null;
+  reactions: Array<{
+    emoji: string;
+    label: string;
+    count: number;
+    isSelected: boolean;
+  }>;
+};
+type CommentThread = {
+  canPost: boolean;
+  allowMentions: boolean;
+  allowAttachments: boolean;
+  notificationsEnabled: boolean;
+  quickReactions: ReadonlyArray<{
+    emoji: string;
+    label: string;
+  }>;
+  total: number;
+  /** Pass it back as `offset` for the next page. `null` on the last page. */
+  nextOffset: number | null;
+  items: Array<CommentView>;
+};
+/**
+ * The thread on one record, or `null` when this visitor cannot see comments on it. Render nothing
+ * for `null`.
+ *
+ * @example
+ * const thread = await comments.list(orderComments, { recordId: order.id })
+ */
+declare function listComments(action: CommentsAction, options: {
+  recordId: string;
+  offset?: number | null;
+  limit?: number;
+}): Promise<CommentThread | null>;
+/**
+ * Posts a comment. `body` is the text the visitor typed. `mentions` are the people they picked,
+ * each with the range of its `@name` in `body`. A range that no longer reads as `@name` is posted as
+ * plain text. `attachments` are the files `useFileUpload` finished uploading.
+ *
+ * @example
+ * await comments.create(orderComments, { recordId, body: "Hey @Ann", mentions, attachments })
+ */
+declare function createComment(action: CommentsAction, options: {
+  recordId: string;
+  body: string;
+  mentions: ReadonlyArray<CommentMention>;
+  attachments?: ReadonlyArray<CommentAttachmentInput>;
+}): Promise<void>;
+/**
+ * Saves an edit. Offer it only where the comment's `canEdit` is true, and fill the edit box from its
+ * `source`. `attachments` is the full list after the edit: the files kept plus any new ones.
+ *
+ * @example
+ * await comments.update(orderComments, { recordId, commentId, body, mentions, attachments })
+ */
+declare function updateComment(action: CommentsAction, options: {
+  recordId: string;
+  commentId: string;
+  body: string;
+  mentions: ReadonlyArray<CommentMention>;
+  attachments: ReadonlyArray<CommentAttachmentInput>;
+}): Promise<void>;
+/**
+ * Deletes a comment. Offer it only where the comment's `canDelete` is true.
+ *
+ * @example
+ * await comments.delete(orderComments, { recordId, commentId })
+ */
+declare function deleteComment(action: CommentsAction, options: {
+  recordId: string;
+  commentId: string;
+}): Promise<void>;
+/**
+ * Adds the visitor's reaction when `selected` is true, and removes it when false. Pass the
+ * reaction's current `isSelected` negated.
+ *
+ * @example
+ * await comments.react(orderComments, { recordId, commentId, emoji: "👍", selected: true })
+ */
+declare function reactToComment(action: CommentsAction, options: {
+  recordId: string;
+  commentId: string;
+  emoji: string;
+  selected: boolean;
+}): Promise<void>;
+/**
+ * Whether the visitor gets an email when someone comments on this record.
+ *
+ * @example
+ * const subscribed = await comments.subscription(orderComments, { recordId })
+ */
+declare function readSubscription(action: CommentsAction, options: {
+  recordId: string;
+}): Promise<boolean>;
+/**
+ * Turns the visitor's emails about this record's comments on or off.
+ *
+ * @example
+ * await comments.setSubscription(orderComments, { recordId, subscribed: false })
+ */
+declare function setSubscription(action: CommentsAction, options: {
+  recordId: string;
+  subscribed: boolean;
+}): Promise<void>;
+/**
+ * The people the visitor may mention whose name or email matches `query`. Only call it when the
+ * thread's `allowMentions` is true.
+ *
+ * @example
+ * const people = await comments.searchMentions(orderComments, { query: "an" })
+ */
+declare function searchMentions(action: CommentsAction, options: {
+  query: string;
+}): Promise<Array<{
+  name: string;
+  email: string;
+  avatar: string | null;
+}>>;
+declare const comments: {
+  list: typeof listComments;
+  create: typeof createComment;
+  update: typeof updateComment;
+  delete: typeof deleteComment;
+  react: typeof reactToComment;
+  subscription: typeof readSubscription;
+  setSubscription: typeof setSubscription;
+  searchMentions: typeof searchMentions;
+};
+//#endregion
+export { CommentAttachmentInput, CommentMention, CommentThread, CommentView, comments };