graze-client 0.8.0 → 0.9.0

package/src/schema/UpdateAlgorithmPayload.ts

@@ -5,30 +5,43 @@ import { Schema as S } from "effect";
 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"),
+  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")
-);
+  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 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.Literal("reply", "quote");
+export const PostType = S.Literals(["reply", "quote"]);
 export type PostType = typeof PostType.Type;
 
 // ------------------- Filters ------------------------------------
@@ -60,7 +73,7 @@ export type AttributeCompare = Readonly<{
   attribute_compare: readonly [
     AttributeName,
     AttributeComparison,
-    AttributeValue
+    AttributeValue,
   ];
 }>;
 export type RegexMatches = Readonly<{
@@ -70,10 +83,10 @@ export type RegexNegationMatches = Readonly<{
   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];
@@ -84,77 +97,77 @@ export type EntityExcludesLabels = Readonly<{
 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"];
 }>;
 
-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 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
-  ),
+    AttributeValue,
+  ]),
 });
-const RegexMatchBase = S.Tuple(
+const RegexMatchBase = S.Tuple([
   AttributeName,
-  S.String.annotations({
+  S.String.annotate({
     title: "Regex Pattern",
     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.",
-  })
-);
+  }),
+]);
 export const RegexMatches = S.Struct({
   regex_matches: RegexMatchBase,
 });
 export const RegexNegationMatches = S.Struct({
   regex_negation_matches: RegexMatchBase,
 });
-const TextMatchBase = S.Tuple(
+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.",
   }),
-  S.Boolean.annotations({
+  S.Boolean.annotate({
     title: "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.",
-  })
-);
+  }),
+]);
 export const TextMatchesAny = S.Struct({
   regex_any: TextMatchBase,
 });
@@ -162,33 +175,33 @@ export const TextMatchesNone = S.Struct({
   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.",
-    })
-  ),
+    }),
+  ]),
 });
 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 -----------------------------
@@ -207,28 +220,28 @@ export type SortSettings = typeof SortSettings.Type;
 
 // ---------------------- Form Data  ---------------------------------
 
-export const DisplayName = S.String.annotations({
+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({
+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({
+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")
-);
+  S.Literal("old"),
+]);
 export type Order = typeof Order.Type;
 
 export const FeedId = S.NumberFromString;
@@ -248,8 +261,8 @@ export const Metadata = S.Struct({
   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),
 });
@@ -263,8 +276,8 @@ 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)),
+  algorithm_manifest: S.fromJsonString(AlgorithmManifest),
+  metadata: S.optional(S.fromJsonString(Metadata)),
 });
 export type FullForm = typeof FullForm.Type;
 export type EncodedFullForm = typeof FullForm.Encoded;

package/src/schema/shared.ts

@@ -2,25 +2,25 @@ 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),
+  deleted_at: S.Union([S.DateFromString, S.Null]),
 });
 export type PartialAlgorithm = typeof PartialAlgorithm.Type;
 
@@ -46,7 +46,7 @@ export const AlgoUpdateResponse = S.Struct({
 });
 export type AlgoUpdateResponse = typeof AlgoUpdateResponse.Type;
 
-export const GetAlgoResponse = S.parseJson(FullAlgorithmWithManifest);
+export const GetAlgoResponse = S.fromJsonString(FullAlgorithmWithManifest);
 export type GetAlgoResponse = typeof GetAlgoResponse.Type;
 
 export const HidePostBody = S.Struct({

package/src/stickyposts.ts

@@ -1,5 +1,5 @@
-import { HttpApiGroup, HttpApiEndpoint } from "@effect/platform";
-import { Schema } from "effect";
+import { Schema, SchemaTransformation } from "effect";
+import { FeedIdParam } from "./common.js";
 import {
   CreateStickyPostBody,
   GetStickyPostsBody,
@@ -7,37 +7,58 @@ import {
   StickyPostSuccess,
   StickyType,
 } from "./schema/StickyPosts.js";
-import { FeedIdParam } from "./common.js";
+import * as HttpApiEndpoint from "effect/unstable/httpapi/HttpApiEndpoint";
+import * as HttpApiGroup from "effect/unstable/httpapi/HttpApiGroup";
+
+// v4 dropped `Schema.BooleanFromString`; decode the query strings "true"/"false".
+const BooleanFromString = Schema.Literals(["true", "false"]).pipe(
+  Schema.decodeTo(
+    Schema.Boolean,
+    SchemaTransformation.transform({
+      decode: (s) => s === "true",
+      encode: (b) => (b ? "true" : "false"),
+    }),
+  ),
+);
 
 export const StickyPostsApiGroup = HttpApiGroup.make("stickyposts")
   .add(
-    HttpApiEndpoint.post("create")`/app/api/v1/feed-management/sticky-posts`
-      .setPayload(CreateStickyPostBody)
-      .addSuccess(StickyPostSuccess)
+    HttpApiEndpoint.post("create", "/app/api/v1/feed-management/sticky-posts", {
+      payload: CreateStickyPostBody,
+      success: StickyPostSuccess,
+    }),
   )
   .add(
     HttpApiEndpoint.get(
-      "get"
-    )`/app/api/v1/feed-management/sticky-posts/${FeedIdParam}`.addSuccess(
-      GetStickyPostsBody
-    )
+      "get",
+      "/app/api/v1/feed-management/sticky-posts/:feedId",
+      {
+        params: { feedId: FeedIdParam },
+        success: GetStickyPostsBody,
+      },
+    ),
   )
   .add(
     HttpApiEndpoint.put(
-      "update"
-    )`/app/api/v1/feed-management/sticky-posts/${FeedIdParam}/${StickyPostIdParam}`
-      .setUrlParams(
-        Schema.Struct({
-          is_active: Schema.BooleanFromString,
+      "update",
+      "/app/api/v1/feed-management/sticky-posts/:feedId/:stickyPostId",
+      {
+        params: { feedId: FeedIdParam, stickyPostId: StickyPostIdParam },
+        query: Schema.Struct({
+          is_active: BooleanFromString,
           sticky_type: StickyType,
-        })
-      )
-      .addSuccess(StickyPostSuccess)
+        }),
+        success: StickyPostSuccess,
+      },
+    ),
   )
   .add(
-    HttpApiEndpoint.del(
-      "delete"
-    )`/app/api/v1/feed-management/sticky-posts/${FeedIdParam}/${StickyPostIdParam}`.addSuccess(
-      StickyPostSuccess
-    )
+    HttpApiEndpoint.make("DELETE")(
+      "delete",
+      "/app/api/v1/feed-management/sticky-posts/:feedId/:stickyPostId",
+      {
+        params: { feedId: FeedIdParam, stickyPostId: StickyPostIdParam },
+        success: StickyPostSuccess,
+      },
+    ),
   );