@liase/core 1.0.0

package/dist/plugins/built-in-sources/bluesky/requestHandlers/mediaSearch.d.ts

@@ -0,0 +1,390 @@
+import { z } from "zod";
+declare const _default: {
+    readonly id: "search";
+    readonly displayName: "Search";
+    readonly description: "Search network for media";
+    readonly requestSchema: z.ZodObject<{
+        source: z.ZodString;
+        queryType: z.ZodString;
+        sort: z.ZodOptional<z.ZodEnum<["latest", "top"]>>;
+        searchText: z.ZodDefault<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        since: z.ZodOptional<z.ZodUnion<[z.ZodDate, z.ZodString]>>;
+        until: z.ZodOptional<z.ZodUnion<[z.ZodDate, z.ZodString]>>;
+        cursor: z.ZodOptional<z.ZodString>;
+        maxPostCount: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strict", z.ZodTypeAny, {
+        source: string;
+        queryType: string;
+        maxPostCount: number;
+        searchText: string;
+        sort?: "latest" | "top" | undefined;
+        cursor?: string | undefined;
+        tags?: string[] | undefined;
+        since?: string | Date | undefined;
+        until?: string | Date | undefined;
+    }, {
+        source: string;
+        queryType: string;
+        sort?: "latest" | "top" | undefined;
+        cursor?: string | undefined;
+        tags?: string[] | undefined;
+        maxPostCount?: number | undefined;
+        searchText?: string | undefined;
+        since?: string | Date | undefined;
+        until?: string | Date | undefined;
+    }>;
+    readonly secretsSchema: z.ZodObject<{
+        handle: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        serviceUrl: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        password?: string | undefined;
+        handle?: string | undefined;
+        serviceUrl?: string | undefined;
+    }, {
+        password?: string | undefined;
+        handle?: string | undefined;
+        serviceUrl?: string | undefined;
+    }>;
+    readonly paginationType: "cursor";
+    readonly responses: [{
+        readonly schema: z.ZodObject<{
+            page: z.ZodObject<{
+                paginationType: z.ZodLiteral<"cursor">;
+                cursor: z.ZodOptional<z.ZodString>;
+                nextCursor: z.ZodNullable<z.ZodString>;
+                isLastPage: z.ZodBoolean;
+                pageFetchLimitReached: z.ZodBoolean;
+            }, "strict", z.ZodTypeAny, {
+                paginationType: "cursor";
+                isLastPage: boolean;
+                pageFetchLimitReached: boolean;
+                nextCursor: string | null;
+                cursor?: string | undefined;
+            }, {
+                paginationType: "cursor";
+                isLastPage: boolean;
+                pageFetchLimitReached: boolean;
+                nextCursor: string | null;
+                cursor?: string | undefined;
+            }>;
+            media: z.ZodArray<z.ZodObject<{
+                mediaFinderSource: z.ZodLiteral<"bluesky">;
+                id: z.ZodString;
+                title: z.ZodString;
+                url: z.ZodString;
+                dateUploaded: z.ZodDate;
+                usernameOfUploader: z.ZodString;
+                nameOfUploader: z.ZodString;
+                files: z.ZodTuple<[z.ZodObject<{
+                    url: z.ZodString;
+                    ext: z.ZodString;
+                    mimeType: z.ZodString;
+                    image: z.ZodBoolean;
+                    video: z.ZodBoolean;
+                    fileSize: z.ZodOptional<z.ZodNumber>;
+                    aspectRatio: z.ZodOptional<z.ZodObject<{
+                        height: z.ZodNumber;
+                        width: z.ZodNumber;
+                    }, "strict", z.ZodTypeAny, {
+                        width: number;
+                        height: number;
+                    }, {
+                        width: number;
+                        height: number;
+                    }>>;
+                } & {
+                    type: z.ZodLiteral<"full">;
+                }, "strict", z.ZodTypeAny, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }>, z.ZodObject<{
+                    url: z.ZodString;
+                    ext: z.ZodString;
+                    mimeType: z.ZodString;
+                    image: z.ZodBoolean;
+                    video: z.ZodBoolean;
+                    fileSize: z.ZodOptional<z.ZodNumber>;
+                    aspectRatio: z.ZodOptional<z.ZodObject<{
+                        height: z.ZodNumber;
+                        width: z.ZodNumber;
+                    }, "strict", z.ZodTypeAny, {
+                        width: number;
+                        height: number;
+                    }, {
+                        width: number;
+                        height: number;
+                    }>>;
+                } & {
+                    type: z.ZodLiteral<"thumbnail">;
+                }, "strict", z.ZodTypeAny, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }>], null>;
+                contentHash: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                url: string;
+                id: string;
+                contentHash: string;
+                mediaFinderSource: "bluesky";
+                files: [{
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }];
+                nameOfUploader: string;
+                usernameOfUploader: string;
+                title: string;
+                dateUploaded: Date;
+            }, {
+                url: string;
+                id: string;
+                contentHash: string;
+                mediaFinderSource: "bluesky";
+                files: [{
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }];
+                nameOfUploader: string;
+                usernameOfUploader: string;
+                title: string;
+                dateUploaded: Date;
+            }>, "many">;
+            request: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strict", z.ZodTypeAny, {
+            page: {
+                paginationType: "cursor";
+                isLastPage: boolean;
+                pageFetchLimitReached: boolean;
+                nextCursor: string | null;
+                cursor?: string | undefined;
+            };
+            media: {
+                url: string;
+                id: string;
+                contentHash: string;
+                mediaFinderSource: "bluesky";
+                files: [{
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }];
+                nameOfUploader: string;
+                usernameOfUploader: string;
+                title: string;
+                dateUploaded: Date;
+            }[];
+            request: Record<string, unknown>;
+        }, {
+            page: {
+                paginationType: "cursor";
+                isLastPage: boolean;
+                pageFetchLimitReached: boolean;
+                nextCursor: string | null;
+                cursor?: string | undefined;
+            };
+            media: {
+                url: string;
+                id: string;
+                contentHash: string;
+                mediaFinderSource: "bluesky";
+                files: [{
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "full";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }, {
+                    mimeType: string;
+                    ext: string;
+                    video: boolean;
+                    image: boolean;
+                    url: string;
+                    type: "thumbnail";
+                    fileSize?: number | undefined;
+                    aspectRatio?: {
+                        width: number;
+                        height: number;
+                    } | undefined;
+                }];
+                nameOfUploader: string;
+                usernameOfUploader: string;
+                title: string;
+                dateUploaded: Date;
+            }[];
+            request: Record<string, unknown>;
+        }>;
+        readonly constructor: {
+            readonly _setup: ($: import("../../../../ActionContext.js").ActionContext) => Promise<import("@atproto/api/dist/client/types/app/bsky/feed/searchPosts.js").OutputSchema>;
+            readonly page: {
+                readonly paginationType: () => string;
+                readonly cursor: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                readonly nextCursor: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                readonly isLastPage: ($: import("../../../../ActionContext.js").ActionContext) => boolean;
+                readonly pageFetchLimitReached: ($: import("../../../../ActionContext.js").ActionContext) => boolean | undefined;
+            };
+            readonly media: {
+                _arrayMap: ($: import("../../../../ActionContext.js").ActionContext) => {
+                    id: string;
+                    postCid: string;
+                    postUri: string;
+                    postUrl: string;
+                    postTextContents: string;
+                    fileCid: string;
+                    altText: string;
+                    mimeType: string;
+                    filesize: number;
+                    playlistUrl?: string;
+                    thumbnailUrl: string;
+                    fullsizeUrl?: string;
+                    aspectRatio: {
+                        width: number;
+                        height: number;
+                    };
+                    author: {
+                        did: string;
+                        handle: string;
+                        displayName: string;
+                        avatarUrl: string;
+                        createdAt: string;
+                    };
+                    languages: string[];
+                    createdAt: string;
+                }[];
+                mediaFinderSource: string;
+                id: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                contentHash: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                title: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                url: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                dateUploaded: ($: import("../../../../ActionContext.js").ActionContext) => Date;
+                usernameOfUploader: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                nameOfUploader: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                files: {
+                    _arrayMap: ($: import("../../../../ActionContext.js").ActionContext) => any[];
+                    _setup: ($: import("../../../../ActionContext.js").ActionContext) => import("../../../../ActionContext.js").ActionContext;
+                    type: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    url: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    ext: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    mimeType: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    image: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    video: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    fileSize: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                    aspectRatio: ($: import("../../../../ActionContext.js").ActionContext) => any;
+                }[];
+            }[];
+            readonly request: ($: import("../../../../ActionContext.js").ActionContext) => Record<string, any>;
+        };
+    }];
+};
+export default _default;
+//# sourceMappingURL=mediaSearch.d.ts.map

package/dist/plugins/built-in-sources/bluesky/requestHandlers/mediaSearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaSearch.d.ts","sourceRoot":"","sources":["../../../../../src/plugins/built-in-sources/bluesky/requestHandlers/mediaSearch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOxB,wBAiFoC"}

package/dist/plugins/built-in-sources/bluesky/requestHandlers/mediaSearch.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { getAgent } from "../client.js";
+import { postsToMediaResponseConstructor } from "../shared.js";
+import { responseSchema } from "../types.js";
+export default {
+    id: "search",
+    displayName: "Search",
+    description: "Search network for media",
+    requestSchema: z
+        .object({
+        source: z.string(),
+        queryType: z.string(),
+        sort: z.enum(["latest", "top"]).optional(),
+        searchText: z.string().default("*"),
+        tags: z.array(z.string()).optional(),
+        since: z.union([z.date(), z.string()]).optional(),
+        until: z.union([z.date(), z.string()]).optional(),
+        cursor: z.string().optional().describe("The page cursor"),
+        maxPostCount: z
+            .number()
+            .min(1)
+            .max(100)
+            .optional()
+            .default(25)
+            .describe("The max number of posts from which to extract media from"),
+    })
+        .strict(),
+    secretsSchema: z
+        .object({
+        handle: z.string().optional(),
+        password: z.string().optional(),
+        serviceUrl: z.string().optional(),
+    })
+        .strict(),
+    paginationType: "cursor",
+    responses: [
+        {
+            schema: responseSchema,
+            constructor: {
+                _setup: async ($) => {
+                    const params = {
+                        ...($.request.maxPostCount
+                            ? { limit: $.request.maxPostCount }
+                            : {}),
+                        ...($.request.since ? { since: $.request.since } : {}),
+                        ...($.request.until ? { until: $.request.until } : {}),
+                        ...($.request.cursor ? { cursor: $.request.cursor } : {}),
+                        ...($.request.sort ? { sort: $.request.sort } : {}),
+                        q: [
+                            $.request.searchText,
+                            ...($.request.tags || []).map((tag) => `#${tag}`),
+                        ].join(" "),
+                    };
+                    let res;
+                    try {
+                        const agent = await getAgent({
+                            $,
+                            handle: $.secrets.handle,
+                            password: $.secrets.password,
+                            serviceUrl: $.secrets.serviceUrl,
+                        });
+                        const apiRes = await agent.app.bsky.feed.searchPosts(params);
+                        res = apiRes;
+                        if (!apiRes.success) {
+                            throw Error("Unsuccessful request to Bluesky");
+                        }
+                        return apiRes.data;
+                    }
+                    catch (error) {
+                        console.info("Request sent to Bluesky:", params);
+                        console.info("Response:", res);
+                        throw error;
+                    }
+                },
+                page: {
+                    paginationType: () => "cursor",
+                    cursor: ($) => $.request.cursor || "",
+                    nextCursor: ($) => $().cursor ?? null,
+                    isLastPage: ($) => typeof $().cursor === "undefined",
+                    pageFetchLimitReached: ($) => $.pageFetchLimitReached,
+                },
+                media: postsToMediaResponseConstructor,
+                request: ($) => $.request,
+            },
+        },
+    ],
+};