graze-client 0.8.1 → 0.9.0

package/src/schema/StickyPosts.ts

@@ -1,33 +1,29 @@
-import { HttpApiSchema } from "@effect/platform"
-import { Schema as S } from "effect"
-import { Post } from "./Post.js"
+import { Schema as S } from "effect";
+import { Post } from "./Post.js";
 
-export const StickyPostIdParam = HttpApiSchema.param(
-  "stickyPostId",
-  S.NumberFromString
-)
-export type StickyPostIdParam = typeof StickyPostIdParam.Type
+export const StickyPostIdParam = S.NumberFromString;
+export type StickyPostIdParam = typeof StickyPostIdParam.Type;
 
 export const StoppingCriteria = S.Struct({
-  expiration_time: S.Number.pipe(S.optional)
-})
-export type StoppingCriteria = typeof StoppingCriteria.Type
+  expiration_time: S.Number.pipe(S.optional),
+});
+export type StoppingCriteria = typeof StoppingCriteria.Type;
 
-export const StickyType = S.Literal("pinned", "rotating")
-export type StickyType = typeof StickyType.Type
+export const StickyType = S.Literals(["pinned", "rotating"]);
+export type StickyType = typeof StickyType.Type;
 
 const StickyPostBase = S.Struct({
   is_active: S.Boolean,
-  sticky_type: StickyType
-})
+  sticky_type: StickyType,
+});
 
 export const CreateStickyPostBody = S.Struct({
   algo_id: S.Number,
   post_url: S.String,
   stopping_criteria: StoppingCriteria.pipe(S.optional),
-  ...StickyPostBase.fields
-})
-export type CreateStickyPostBody = typeof CreateStickyPostBody.Type
+  ...StickyPostBase.fields,
+});
+export type CreateStickyPostBody = typeof CreateStickyPostBody.Type;
 
 export const GetStickyPostsBody = S.Struct({
   sticky_posts: S.Array(
@@ -40,13 +36,13 @@ export const GetStickyPostsBody = S.Struct({
       post: Post,
       author: S.String,
       created_at: S.String,
-      updated_at: S.String
-    })
-  )
-})
-export type GetStickyPostsBody = typeof GetStickyPostsBody.Type
+      updated_at: S.String,
+    }),
+  ),
+});
+export type GetStickyPostsBody = typeof GetStickyPostsBody.Type;
 
 export const StickyPostSuccess = S.Struct({
-  message: S.String
-})
-export type StickyPostSuccess = typeof StickyPostSuccess.Type
+  message: S.String,
+});
+export type StickyPostSuccess = typeof StickyPostSuccess.Type;

package/src/schema/UpdateAlgorithmPayload.ts

@@ -1,11 +1,11 @@
-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(
+export const AttributeName = S.Union([
   S.Literal("text"),
   S.Literal("reply"),
   S.Literal("embed.images[*].alt"),
@@ -27,15 +27,22 @@ export const AttributeName = S.Union(
   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
+  S.Literal("hydrated_metadata.mentions.display_name"),
+]);
+export type AttributeName = typeof AttributeName.Type;
+export const AttributeComparison = S.Literals([
+  "==",
+  "!=",
+  ">",
+  "<",
+  ">=",
+  "<=",
+]);
+export type AttributeComparison = typeof AttributeComparison.Type;
+export const AttributeValue = S.Null;
+export type AttributeValue = typeof AttributeValue.Type;
+export const PostType = S.Literals(["reply", "quote"]);
+export type PostType = typeof PostType.Type;
 
 // ------------------- Filters ------------------------------------
 
@@ -52,149 +59,150 @@ 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
-  ]
-}>
+    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, ReadonlyArray<string>, boolean, boolean]
-}>
+  regex_any: readonly [AttributeName, ReadonlyArray<string>, boolean, boolean];
+}>;
 export type TextMatchesNone = Readonly<{
-  regex_none: readonly [AttributeName, ReadonlyArray<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"
-  ]
-}>
+    "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),
-  S.suspend((): S.Schema<Or> => Or),
-  S.suspend((): S.Schema<ListMemberFilter> => ListMemberFilter),
-  S.suspend((): S.Schema<AttributeCompare> => AttributeCompare),
-  S.suspend((): S.Schema<RegexMatches> => RegexMatches),
-  S.suspend((): S.Schema<RegexNegationMatches> => RegexNegationMatches),
-  S.suspend((): S.Schema<TextMatchesAny> => TextMatchesAny),
-  S.suspend((): S.Schema<TextMatchesNone> => TextMatchesNone),
-  S.suspend((): S.Schema<ContentModerationBlock> => ContentModerationBlock),
-  S.suspend((): S.Schema<EntityExcludesLabels> => EntityExcludesLabels),
-  S.suspend((): S.Schema<EmbedType> => EmbedType),
-  S.suspend((): S.Schema<SocialGraph> => SocialGraph),
-  S.suspend((): S.Schema<PostTypeFilter> => PostTypeFilter)
-)
+export const Filter = S.Union([
+  S.suspend((): S.Codec<And> => And),
+  S.suspend((): S.Codec<Or> => Or),
+  S.suspend((): S.Codec<ListMemberFilter> => ListMemberFilter),
+  S.suspend((): S.Codec<AttributeCompare> => AttributeCompare),
+  S.suspend((): S.Codec<RegexMatches> => RegexMatches),
+  S.suspend((): S.Codec<RegexNegationMatches> => RegexNegationMatches),
+  S.suspend((): S.Codec<TextMatchesAny> => TextMatchesAny),
+  S.suspend((): S.Codec<TextMatchesNone> => TextMatchesNone),
+  S.suspend((): S.Codec<ContentModerationBlock> => ContentModerationBlock),
+  S.suspend((): S.Codec<EntityExcludesLabels> => EntityExcludesLabels),
+  S.suspend((): S.Codec<EmbedType> => EmbedType),
+  S.suspend((): S.Codec<SocialGraph> => SocialGraph),
+  S.suspend((): S.Codec<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.Literals(["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.Literals(["in", "not_in"])]),
+});
 export const AttributeCompare = S.Struct({
-  attribute_compare: S.Tuple(
+  attribute_compare: S.Tuple([
     AttributeName,
     AttributeComparison,
-    AttributeValue
-  )
-})
-const RegexMatchBase = S.Tuple(
+    AttributeValue,
+  ]),
+});
+const RegexMatchBase = S.Tuple([
   AttributeName,
-  S.String.annotations({
+  S.String.annotate({
     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({
+  S.Boolean.annotate({
     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
-})
-const TextMatchBase = S.Tuple(
+  regex_negation_matches: RegexMatchBase,
+});
+const TextMatchBase = S.Tuple([
   AttributeName,
-  S.Array(S.String).annotations({
+  S.Array(S.String).annotate({
     title: "Text Patterns",
-    description: "List of possible text patterns to match against."
+    description: "List of possible text patterns to match against.",
   }),
-  S.Boolean.annotations({
+  S.Boolean.annotate({
     title: "Case Insensitive?",
-    description: "True if the matching should be case insensitive."
+    description: "True if the matching should be case insensitive.",
   }),
-  S.Boolean.annotations({
+  S.Boolean.annotate({
     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(
+  content_moderation: S.Tuple([
     S.Literal("OK"),
     S.Literal(">="),
-    S.Number.annotations({
+    S.Number.annotate({
       title: "Threshold",
-      description: "The threshold for content moderation."
-    })
-  )
-})
+      description: "The threshold for content moderation.",
+    }),
+  ]),
+});
 export const EntityExcludesLabels = S.Struct({
-  entity_excludes: S.Tuple(
+  entity_excludes: S.Tuple([
     S.Literal("labels"),
-    S.Tuple(S.Literal("porn"), S.Literal("sexual"), S.Literal("nudity"))
-  )
-})
+    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")
-  )
-})
+  embed_type: S.Tuple([
+    S.Literals(["==", "!="]),
+    S.Literals(["video", "image", "link", "post", "gif", "image_group"]),
+  ]),
+});
 export const SocialGraph = S.Struct({
-  social_graph: S.Tuple(
+  social_graph: S.Tuple([
     S.String,
-    S.Literal("in", "not_in"),
-    S.Literal("follows", "followers")
-  )
-})
+    S.Literals(["in", "not_in"]),
+    S.Literals(["follows", "followers"]),
+  ]),
+});
 
 // ---------------------- Sort Settings -----------------------------
 
@@ -206,59 +214,59 @@ 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
+export const DisplayName = S.String.annotate({
+  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
+export const RecordName = S.String.annotate({
+  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
+export const Description = S.String.annotate({
+  description: "The description to be shown to users of the feed.",
+});
+export type Description = typeof Description.Type;
 
-export const Order = S.Union(
+export const Order = S.Union([
   S.Literal("new"),
   S.Literal("trending"),
   S.Literal("blend"),
   S.Literal("hackernews"),
-  S.Literal("old")
-)
-export type Order = typeof Order.Type
+  S.Literal("old"),
+]);
+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(S.String, 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,
@@ -268,11 +276,11 @@ export const FullForm = S.Struct({
   record_name: RecordName,
   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
+  algorithm_manifest: S.fromJsonString(AlgorithmManifest),
+  metadata: S.optional(S.fromJsonString(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,65 +1,65 @@
-import { Schema as S } from "effect"
+import { Schema as S } from "effect";
 
 export const PartialAlgorithm = S.Struct({
   algorithm_uri: S.String,
-  algorithm_manifest_id: S.Union(S.Null, S.Number),
+  algorithm_manifest_id: S.Union([S.Null, S.Number]),
   draft_algorithm_manifest_id: S.Number,
   record_name: S.String,
   display_name: S.String,
   description: S.String,
   feed_did: S.String,
-  avatar_url: S.Union(S.String, S.Null),
-  cpm_cents: S.Union(S.Number, S.Null),
+  avatar_url: S.Union([S.String, S.Null]),
+  cpm_cents: S.Union([S.Number, S.Null]),
   deleted: S.Boolean,
   active: S.Boolean,
   public: S.Boolean,
   monetization_available: S.Boolean,
-  status: S.Union(S.String, S.Null),
+  status: S.Union([S.String, S.Null]),
   unique_operator_ids: S.Array(S.Number),
   user_id: S.Number,
   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.fromJsonString(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;