graze-client 0.7.5 → 0.8.1

package/src/schema/UpdateAlgorithmPayload.ts

@@ -1,35 +1,41 @@
-import { Schema as S } from "effect";
+import { Schema as S } from "effect"
 
 // ------------------- Primitives ---------------------------------
 
-export const ListUri = S.String;
-export type ListUri = typeof ListUri.Type;
+export const ListUri = S.String
+export type ListUri = typeof ListUri.Type
 
 export const AttributeName = S.Union(
   S.Literal("text"),
   S.Literal("reply"),
   S.Literal("embed.images[*].alt"),
+  S.Literal("embed.media.images[*].alt"),
   S.Literal("embed.alt"),
   S.Literal("embed"),
   S.Literal("embed.external.uri"),
   S.Literal("embed.external.title"),
   S.Literal("embed.external.description"),
-  S.Literal("embed.images[*].alt"),
   S.Literal("embed.media.external.uri"),
   S.Literal("embed.media.external.title"),
   S.Literal("embed.media.external.description"),
   S.Literal("embed.record.uri"),
-  S.Literal("langs[*"),
+  S.Literal("langs[*]"),
   S.Literal("labels.values[*].val"),
-  S.Literal("facets[*].features[*].uri")
-);
-export type AttributeName = typeof AttributeName.Type;
-export const AttributeComparison = S.Literal("==", "!=", ">", "<", ">=", "<=");
-export type AttributeComparison = typeof AttributeComparison.Type;
-export const AttributeValue = S.Null;
-export type AttributeValue = typeof AttributeValue.Type;
-export const PostType = S.Literal("reply", "quote");
-export type PostType = typeof PostType.Type;
+  S.Literal("facets[*].features[*].uri"),
+  S.Literal("hydrated_metadata.user.did"),
+  S.Literal("hydrated_metadata.user.handle"),
+  S.Literal("hydrated_metadata.user.description"),
+  S.Literal("hydrated_metadata.user.display_name"),
+  S.Literal("hydrated_metadata.user.labels"),
+  S.Literal("hydrated_metadata.mentions.display_name")
+)
+export type AttributeName = typeof AttributeName.Type
+export const AttributeComparison = S.Literal("==", "!=", ">", "<", ">=", "<=")
+export type AttributeComparison = typeof AttributeComparison.Type
+export const AttributeValue = S.Null
+export type AttributeValue = typeof AttributeValue.Type
+export const PostType = S.Literal("reply", "quote")
+export type PostType = typeof PostType.Type
 
 // ------------------- Filters ------------------------------------
 
@@ -46,50 +52,50 @@ export type Filter =
   | EntityExcludesLabels
   | EmbedType
   | SocialGraph
-  | PostTypeFilter;
+  | PostTypeFilter
 
-export type And = Readonly<{ and: ReadonlyArray<Filter> }>;
-export type Or = Readonly<{ or: ReadonlyArray<Filter> }>;
+export type And = Readonly<{ and: ReadonlyArray<Filter> }>
+export type Or = Readonly<{ or: ReadonlyArray<Filter> }>
 export type PostTypeFilter = Readonly<{
-  post_type: readonly ["in" | "not_in", ReadonlyArray<PostType>];
-}>;
+  post_type: readonly ["in" | "not_in", ReadonlyArray<PostType>]
+}>
 export type ListMemberFilter = Readonly<{
-  list_member: readonly [ListUri, "in" | "not_in"];
-}>;
+  list_member: readonly [ListUri, "in" | "not_in"]
+}>
 export type AttributeCompare = Readonly<{
   attribute_compare: readonly [
     AttributeName,
     AttributeComparison,
     AttributeValue
-  ];
-}>;
+  ]
+}>
 export type RegexMatches = Readonly<{
-  regex_matches: readonly [AttributeName, string, boolean];
-}>;
+  regex_matches: readonly [AttributeName, string, boolean]
+}>
 export type RegexNegationMatches = Readonly<{
-  regex_negation_matches: readonly [AttributeName, string, boolean];
-}>;
+  regex_negation_matches: readonly [AttributeName, string, boolean]
+}>
 export type TextMatchesAny = Readonly<{
-  regex_any: readonly [AttributeName, readonly string[], boolean, boolean];
-}>;
+  regex_any: readonly [AttributeName, ReadonlyArray<string>, boolean, boolean]
+}>
 export type TextMatchesNone = Readonly<{
-  regex_none: readonly [AttributeName, readonly string[], boolean, boolean];
-}>;
+  regex_none: readonly [AttributeName, ReadonlyArray<string>, boolean, boolean]
+}>
 export type ContentModerationBlock = Readonly<{
-  content_moderation: readonly ["OK", ">=", number];
-}>;
+  content_moderation: readonly ["OK", ">=", number]
+}>
 export type EntityExcludesLabels = Readonly<{
-  entity_excludes: readonly ["labels", readonly ["porn", "sexual", "nudity"]];
-}>;
+  entity_excludes: readonly ["labels", readonly ["porn", "sexual", "nudity"]]
+}>
 export type EmbedType = Readonly<{
   embed_type: readonly [
     "==" | "!=",
     "video" | "image" | "link" | "post" | "gif" | "image_group"
-  ];
-}>;
+  ]
+}>
 export type SocialGraph = Readonly<{
-  social_graph: readonly [string, "in" | "not_in", "follows" | "followers"];
-}>;
+  social_graph: readonly [string, "in" | "not_in", "follows" | "followers"]
+}>
 
 export const Filter = S.Union(
   S.suspend((): S.Schema<And> => And),
@@ -105,91 +111,90 @@ export const Filter = S.Union(
   S.suspend((): S.Schema<EmbedType> => EmbedType),
   S.suspend((): S.Schema<SocialGraph> => SocialGraph),
   S.suspend((): S.Schema<PostTypeFilter> => PostTypeFilter)
-);
+)
 
-export const Or = S.Struct({ or: S.Array(Filter) });
-export const And = S.Struct({ and: S.Array(Filter) });
+export const Or = S.Struct({ or: S.Array(Filter) })
+export const And = S.Struct({ and: S.Array(Filter) })
 export const PostTypeFilter = S.Struct({
-  post_type: S.Tuple(S.Literal("in", "not_in"), S.Array(PostType)),
-});
+  post_type: S.Tuple(S.Literal("in", "not_in"), S.Array(PostType))
+})
 export const ListMemberFilter = S.Struct({
-  list_member: S.Tuple(ListUri, S.Literal("in", "not_in")),
-});
+  list_member: S.Tuple(ListUri, S.Literal("in", "not_in"))
+})
 export const AttributeCompare = S.Struct({
   attribute_compare: S.Tuple(
     AttributeName,
     AttributeComparison,
     AttributeValue
-  ),
-});
+  )
+})
 const RegexMatchBase = S.Tuple(
   AttributeName,
   S.String.annotations({
     title: "Regex Pattern",
-    description: "The source of the regex pattern to match against.",
+    description: "The source of the regex pattern to match against."
   }),
   S.Boolean.annotations({
     title: "Case Insensitive?",
-    description: "True if the regex should be case insensitive.",
+    description: "True if the regex should be case insensitive."
   })
-);
+)
 export const RegexMatches = S.Struct({
-  regex_matches: RegexMatchBase,
-});
+  regex_matches: RegexMatchBase
+})
 export const RegexNegationMatches = S.Struct({
-  regex_negation_matches: RegexMatchBase,
-});
+  regex_negation_matches: RegexMatchBase
+})
 const TextMatchBase = S.Tuple(
   AttributeName,
   S.Array(S.String).annotations({
     title: "Text Patterns",
-    description: "List of possible text patterns to match against.",
+    description: "List of possible text patterns to match against."
   }),
   S.Boolean.annotations({
     title: "Case Insensitive?",
-    description: "True if the matching should be case insensitive.",
+    description: "True if the matching should be case insensitive."
   }),
   S.Boolean.annotations({
     title: "Use Regex?",
-    description:
-      "True if the values should be treated as regex patterns, false for literal strings.",
+    description: "True if the values should be treated as regex patterns, false for literal strings."
   })
-);
+)
 export const TextMatchesAny = S.Struct({
-  regex_any: TextMatchBase,
-});
+  regex_any: TextMatchBase
+})
 export const TextMatchesNone = S.Struct({
-  regex_none: TextMatchBase,
-});
+  regex_none: TextMatchBase
+})
 export const ContentModerationBlock = S.Struct({
   content_moderation: S.Tuple(
     S.Literal("OK"),
     S.Literal(">="),
     S.Number.annotations({
       title: "Threshold",
-      description: "The threshold for content moderation.",
+      description: "The threshold for content moderation."
     })
-  ),
-});
+  )
+})
 export const EntityExcludesLabels = S.Struct({
   entity_excludes: S.Tuple(
     S.Literal("labels"),
     S.Tuple(S.Literal("porn"), S.Literal("sexual"), S.Literal("nudity"))
-  ),
-});
+  )
+})
 export const EmbedType = S.Struct({
   embed_type: S.Tuple(
     S.Literal("==", "!="),
     S.Literal("video", "image", "link", "post", "gif", "image_group")
-  ),
-});
+  )
+})
 export const SocialGraph = S.Struct({
   social_graph: S.Tuple(
     S.String,
     S.Literal("in", "not_in"),
     S.Literal("follows", "followers")
-  ),
-});
+  )
+})
 
 // ---------------------- Sort Settings -----------------------------
 
@@ -201,26 +206,26 @@ export const SortSettings = S.Struct({
   repost_count_multiplier: S.Number,
   reader_like_count_multiplier: S.Number,
   reader_reply_count_multiplier: S.Number,
-  reader_repost_count_multiplier: S.Number,
-});
-export type SortSettings = typeof SortSettings.Type;
+  reader_repost_count_multiplier: S.Number
+})
+export type SortSettings = typeof SortSettings.Type
 
 // ---------------------- Form Data  ---------------------------------
 
 export const DisplayName = S.String.annotations({
-  description: "The public name of the feed.",
-});
-export type DisplayName = typeof DisplayName.Type;
+  description: "The public name of the feed."
+})
+export type DisplayName = typeof DisplayName.Type
 
 export const RecordName = S.String.annotations({
-  description: "The slug of the feed url.",
-});
-export type RecordName = typeof RecordName.Type;
+  description: "The slug of the feed url."
+})
+export type RecordName = typeof RecordName.Type
 
 export const Description = S.String.annotations({
-  description: "The description to be shown to users of the feed.",
-});
-export type Description = typeof Description.Type;
+  description: "The description to be shown to users of the feed."
+})
+export type Description = typeof Description.Type
 
 export const Order = S.Union(
   S.Literal("new"),
@@ -228,32 +233,32 @@ export const Order = S.Union(
   S.Literal("blend"),
   S.Literal("hackernews"),
   S.Literal("old")
-);
-export type Order = typeof Order.Type;
+)
+export type Order = typeof Order.Type
 
-export const FeedId = S.NumberFromString;
-export type FeedId = typeof FeedId.Type;
+export const FeedId = S.NumberFromString
+export type FeedId = typeof FeedId.Type
 
-export const UserId = S.NumberFromString;
-export type UserId = typeof UserId.Type;
+export const UserId = S.NumberFromString
+export type UserId = typeof UserId.Type
 
 export const AlgorithmManifest = S.Struct({
   filter: Filter,
-  sort_settings: S.optional(SortSettings),
-});
-export type AlgorithmManifest = typeof AlgorithmManifest.Type;
+  sort_settings: S.optional(SortSettings)
+})
+export type AlgorithmManifest = typeof AlgorithmManifest.Type
 
 export const Metadata = S.Struct({
   document: S.optional(S.Unknown),
   schema: S.optional(
     S.Struct({
       schemaVersion: S.Literal(2),
-      sequences: S.Record({ key: S.String, value: S.Number }),
+      sequences: S.Record({ key: S.String, value: S.Number })
     })
   ),
-  session: S.optional(S.Unknown),
-});
-export type Metadata = typeof Metadata.Type;
+  session: S.optional(S.Unknown)
+})
+export type Metadata = typeof Metadata.Type
 
 export const FullForm = S.Struct({
   id: FeedId,
@@ -264,10 +269,10 @@ export const FullForm = S.Struct({
   description: S.optional(Description),
   order: Order,
   algorithm_manifest: S.parseJson(AlgorithmManifest),
-  metadata: S.optional(S.parseJson(Metadata)),
-});
-export type FullForm = typeof FullForm.Type;
-export type EncodedFullForm = typeof FullForm.Encoded;
+  metadata: S.optional(S.parseJson(Metadata))
+})
+export type FullForm = typeof FullForm.Type
+export type EncodedFullForm = typeof FullForm.Encoded
 
 /**
  * Actual structure of FormData

package/src/schema/index.ts

@@ -1,2 +1,2 @@
-export * from "./shared.js";
-export * from "./UpdateAlgorithmPayload.js";
+export * from "./shared.js"
+export * from "./UpdateAlgorithmPayload.js"

package/src/schema/shared.ts

@@ -1,4 +1,4 @@
-import { Schema as S } from "effect";
+import { Schema as S } from "effect"
 
 export const PartialAlgorithm = S.Struct({
   algorithm_uri: S.String,
@@ -20,46 +20,46 @@ export const PartialAlgorithm = S.Struct({
   id: S.Number,
   created_at: S.DateFromString,
   updated_at: S.DateFromString,
-  deleted_at: S.Union(S.DateFromString, S.Null),
-});
-export type PartialAlgorithm = typeof PartialAlgorithm.Type;
+  deleted_at: S.Union(S.DateFromString, S.Null)
+})
+export type PartialAlgorithm = typeof PartialAlgorithm.Type
 
-const Stats = S.Unknown;
-const LatestError = S.Unknown;
+const Stats = S.Unknown
+const LatestError = S.Unknown
 
 const FullAlgorithm = S.Struct({
   ...PartialAlgorithm.fields,
   stats: Stats,
   latest_error: LatestError,
   latest_compute_cycle: S.Unknown,
-  subscriber_lists: S.Unknown,
-});
+  subscriber_lists: S.Unknown
+})
 const FullAlgorithmWithManifest = S.Struct({
   ...FullAlgorithm.fields,
   draft_algorithm_manifest: S.Unknown,
-  algorithm_manifest: S.Unknown,
-});
+  algorithm_manifest: S.Unknown
+})
 
 export const AlgoUpdateResponse = S.Struct({
   message: S.String,
-  algorithm: PartialAlgorithm,
-});
-export type AlgoUpdateResponse = typeof AlgoUpdateResponse.Type;
+  algorithm: PartialAlgorithm
+})
+export type AlgoUpdateResponse = typeof AlgoUpdateResponse.Type
 
-export const GetAlgoResponse = S.parseJson(FullAlgorithmWithManifest);
-export type GetAlgoResponse = typeof GetAlgoResponse.Type;
+export const GetAlgoResponse = S.parseJson(FullAlgorithmWithManifest)
+export type GetAlgoResponse = typeof GetAlgoResponse.Type
 
 export const HidePostBody = S.Struct({
   algo_id: S.Number,
-  at_uri: S.String,
-});
-export type HidePostBody = typeof HidePostBody.Type;
+  at_uri: S.String
+})
+export type HidePostBody = typeof HidePostBody.Type
 
 export const UnhidePostBody = S.Struct({
   algo_id: S.Number,
-  at_uri: S.String,
-});
-export type UnhidePostBody = typeof UnhidePostBody.Type;
+  at_uri: S.String
+})
+export type UnhidePostBody = typeof UnhidePostBody.Type
 
 // ----------------------- Get Algorithms Response -----------------------
 
@@ -68,15 +68,15 @@ export const AlgorithWithStats = S.Struct({
   stats: S.Struct({
     page_renders: S.Number,
     unique_users: S.Number,
-    post_renders: S.Number,
-  }),
-});
-export type AlgorithmWithStats = typeof AlgorithWithStats.Type;
+    post_renders: S.Number
+  })
+})
+export type AlgorithmWithStats = typeof AlgorithWithStats.Type
 export const GetAlgorithmsResponse = S.Struct({
   page: S.Number,
   page_size: S.Number,
   total_items: S.Number,
   total_pages: S.Number,
-  user_algos: S.Array(AlgorithWithStats),
-});
-export type GetAlgorithmsResponse = typeof GetAlgorithmsResponse.Type;
+  user_algos: S.Array(AlgorithWithStats)
+})
+export type GetAlgorithmsResponse = typeof GetAlgorithmsResponse.Type

package/src/stickyposts.ts

@@ -1,13 +1,13 @@
-import { HttpApiGroup, HttpApiEndpoint } from "@effect/platform";
-import { Schema } from "effect";
+import { HttpApiEndpoint, HttpApiGroup } from "@effect/platform"
+import { Schema } from "effect"
+import { FeedIdParam } from "./common.js"
 import {
   CreateStickyPostBody,
   GetStickyPostsBody,
   StickyPostIdParam,
   StickyPostSuccess,
-  StickyType,
-} from "./schema/StickyPosts.js";
-import { FeedIdParam } from "./common.js";
+  StickyType
+} from "./schema/StickyPosts.js"
 
 export const StickyPostsApiGroup = HttpApiGroup.make("stickyposts")
   .add(
@@ -29,7 +29,7 @@ export const StickyPostsApiGroup = HttpApiGroup.make("stickyposts")
       .setUrlParams(
         Schema.Struct({
           is_active: Schema.BooleanFromString,
-          sticky_type: StickyType,
+          sticky_type: StickyType
         })
       )
       .addSuccess(StickyPostSuccess)
@@ -40,4 +40,4 @@ export const StickyPostsApiGroup = HttpApiGroup.make("stickyposts")
     )`/app/api/v1/feed-management/sticky-posts/${FeedIdParam}/${StickyPostIdParam}`.addSuccess(
       StickyPostSuccess
     )
-  );
+  )