@liase/core 1.0.0

package/dist/test/testFiles/internal/caching.test.js

@@ -0,0 +1,116 @@
+import { afterEach, expect } from "vitest";
+import currentTimeSource, { startMockServer, stopMockServer, } from "../../fixtures/currentTimeSource.js";
+import { createBasicTestsForRequestHandlers } from "../../utils/vitest.js";
+afterEach(async () => {
+    await stopMockServer();
+});
+createBasicTestsForRequestHandlers({
+    source: currentTimeSource,
+    queries: {
+        "current-time": [
+            {
+                testName: "Responses are not cached if cacheNetworkRequests = never using loadUrl",
+                before: async () => await startMockServer(true),
+                request: {
+                    requestMethod: "loadUrl",
+                },
+                checkAllResponses: (responses) => expect(responses[0].time).not.toEqual(responses[1].time),
+                numOfPagesToLoad: 2,
+                queryOptions: {
+                    cacheNetworkRequests: "never",
+                },
+            },
+            {
+                testName: "Responses are not cached if cacheNetworkRequests = never using fetch",
+                before: async () => await startMockServer(true),
+                request: {
+                    requestMethod: "fetch",
+                },
+                checkAllResponses: (responses) => expect(responses[0].time).not.toEqual(responses[1].time),
+                numOfPagesToLoad: 2,
+                queryOptions: {
+                    cacheNetworkRequests: "never",
+                },
+            },
+            {
+                testName: "cacheNetworkRequests = auto is not currently supported",
+                before: async () => await startMockServer(true),
+                request: {
+                    requestMethod: "fetch",
+                },
+                checkAllResponses: (responses) => expect(responses[0].time).not.toEqual(responses[1].time),
+                numOfPagesToLoad: 2,
+                queryOptions: {
+                    cacheNetworkRequests: "auto",
+                },
+                expectError: /not yet supported/,
+            },
+            {
+                testName: "Responses that indicate they are cacheable are cached if cacheNetworkRequests = always using loadUrl",
+                before: async () => await startMockServer(true),
+                request: {
+                    requestMethod: "loadUrl",
+                },
+                checkAllResponses: (responses) => expect(responses[0].time).toEqual(responses[1].time),
+                numOfPagesToLoad: 2,
+                queryOptions: {
+                    cacheNetworkRequests: "always",
+                },
+            },
+            {
+                testName: "Responses that indicate they are not cacheable are cached anyway if cacheNetworkRequests = always using loadUrl",
+                before: async () => await startMockServer(false),
+                request: {
+                    requestMethod: "loadUrl",
+                },
+                checkAllResponses: (responses) => expect(responses[0].time).toEqual(responses[1].time),
+                numOfPagesToLoad: 2,
+                queryOptions: {
+                    cacheNetworkRequests: "always",
+                },
+            },
+            {
+                testName: "Responses that indicate they are cacheable are cached if cacheNetworkRequests = always using fetch",
+                before: async () => await startMockServer(true),
+                request: {
+                    requestMethod: "fetch",
+                },
+                checkAllResponses: (responses) => expect(responses[0].time).toEqual(responses[1].time),
+                numOfPagesToLoad: 2,
+                queryOptions: {
+                    cacheNetworkRequests: "always",
+                },
+            },
+            {
+                testName: "Responses that indicate they are not cacheable are cached anyway if cacheNetworkRequests = always using fetch",
+                before: async () => await startMockServer(false),
+                request: {
+                    requestMethod: "fetch",
+                },
+                checkAllResponses: (responses) => expect(responses[0].time).toEqual(responses[1].time),
+                numOfPagesToLoad: 2,
+                queryOptions: {
+                    cacheNetworkRequests: "always",
+                },
+            },
+            {
+                testName: "Default setting for cacheNetworkRequests in tests is always",
+                before: async () => await startMockServer(false),
+                request: {
+                    requestMethod: "loadUrl",
+                },
+                checkAllResponses: (responses) => expect(responses[0].time).toEqual(responses[1].time),
+                numOfPagesToLoad: 2,
+            },
+        ],
+    },
+    queriesShared: {
+        finderOptions: {
+            plugins: [
+                {
+                    sources: [currentTimeSource],
+                },
+            ],
+        },
+    },
+});

package/dist/test/testFiles/internal/mediaTypeGuessing.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mediaTypeGuessing.test.d.ts.map

package/dist/test/testFiles/internal/mediaTypeGuessing.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaTypeGuessing.test.d.ts","sourceRoot":"","sources":["../../../../test/testFiles/internal/mediaTypeGuessing.test.ts"],"names":[],"mappings":""}

package/dist/test/testFiles/internal/mediaTypeGuessing.test.js

@@ -0,0 +1,86 @@
+import { guessMediaInfoFromMimeType, guessMediaInfoFromUrl, } from "../../../actionHelpers.js";
+import { expect, test, vi } from "vitest";
+let url;
+let mimeType;
+url = "http://example.com/path/file.mp4";
+test.extend({ url })(`Guess media type from "${url}"`, ({ url }) => {
+    const res = guessMediaInfoFromUrl(url);
+    expect(res).toStrictEqual({
+        url,
+        ext: "mp4",
+        mimeType: "video/mp4",
+        video: true,
+        image: false,
+        audio: undefined,
+    });
+});
+url = "http://example.com/path/file.mp3";
+test.extend({ url })(`Guess media type from "${url}"`, ({ url }) => {
+    const res = guessMediaInfoFromUrl(url, { extra: 42 });
+    expect(res).toStrictEqual({
+        url,
+        ext: "mp3",
+        mimeType: "audio/mpeg",
+        video: false,
+        image: false,
+        audio: true,
+        extra: 42,
+    });
+});
+url = "/path/file.avi";
+test.extend({ url })(`Guess media type from "${url}"`, ({ url }) => {
+    const res = guessMediaInfoFromUrl(url);
+    expect(res).toStrictEqual({
+        url,
+        ext: "avi",
+        mimeType: "video/x-msvideo",
+        video: true,
+        image: false,
+        audio: undefined,
+    });
+});
+url = "http://example.com/path/file";
+test.extend({ url })(`Throw when guessing media type from "${url}"`, ({ url }) => {
+    vi.spyOn(console, "info").mockImplementation(() => { });
+    expect(() => guessMediaInfoFromUrl(url)).toThrowError(/Couldn't derive file type/);
+    vi.restoreAllMocks();
+});
+url = "http://example.com/path/file";
+test.extend({ url })(`Guess media type from "${url}" with ext as additional value`, ({ url }) => {
+    const res = guessMediaInfoFromUrl(url, { ext: "avi" });
+    expect(res).toStrictEqual({
+        url,
+        ext: "avi",
+        mimeType: "video/x-msvideo",
+        video: true,
+        image: false,
+        audio: undefined,
+    });
+});
+url = "http://example.com/path/file";
+test.extend({ url })(`Guess media type from "${url}" with mimeType as additional value`, ({ url }) => {
+    const res = guessMediaInfoFromUrl(url, { mimeType: "video/x-msvideo" });
+    expect(res).toStrictEqual({
+        url,
+        ext: "avi",
+        mimeType: "video/x-msvideo",
+        video: true,
+        image: false,
+        audio: undefined,
+    });
+});
+mimeType = "video/mp4";
+test.extend({ mimeType })(`Guess media type from "${mimeType}"`, ({ mimeType }) => {
+    const res = guessMediaInfoFromMimeType(mimeType);
+    expect(res).toStrictEqual({
+        ext: "mp4",
+        mimeType: "video/mp4",
+        video: true,
+        image: false,
+        audio: undefined,
+    });
+});
+mimeType = "invalid/mime/type";
+test.extend({ mimeType })("Throw when guessing media type from invalid mime type", ({ mimeType }) => {
+    expect(() => guessMediaInfoFromMimeType(mimeType)).toThrowError(/Resource does not appear to be media/);
+});

package/dist/test/testFiles/sources/bluesky.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bluesky.test.d.ts.map

package/dist/test/testFiles/sources/bluesky.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bluesky.test.d.ts","sourceRoot":"","sources":["../../../../test/testFiles/sources/bluesky.test.ts"],"names":[],"mappings":""}

package/dist/test/testFiles/sources/bluesky.test.js

@@ -0,0 +1,40 @@
+import blueskySource from "../../../plugins/built-in-sources/bluesky/index.js";
+import { expect } from "vitest";
+import { getSecrets } from "../../utils/general.js";
+import { createBasicTestsForRequestHandlers } from "../../utils/vitest.js";
+// Search requires Bluesky authentication. Skip when no credentials are present
+// (e.g. in CI). Add handle/password for bluesky in .secrets.mjs to run this test.
+const blueskySecrets = await getSecrets({
+    source: "bluesky",
+    queryType: "search",
+});
+const hasBlueskyCredentials = !!blueskySecrets
+    ?.handle;
+createBasicTestsForRequestHandlers({
+    source: blueskySource,
+    queries: {
+        "single-media": {
+            request: {
+                id: "at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post/3jt6walwmos2y#bafkreidf3ystxebv33boyb5hr2ggwmlee5x53vubwelsuvmcw3tq4p36pi",
+            },
+            checkResponse: (response) => expect(response).toMatchSnapshot(),
+        },
+        search: {
+            request: { searchText: "#photo" },
+            checkResponse: (response) => expect(response.media.length).toBeGreaterThan(2),
+            numOfPagesToLoad: 1,
+            duplicateMediaPossible: true,
+            skip: !hasBlueskyCredentials &&
+                "Bluesky search requires authentication — add .secrets.mjs with handle/password to run",
+        },
+        feed: {
+            request: {
+                feedId: "at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.generator/whats-hot",
+            },
+            checkResponse: (response) => expect(response.media.length).toBeGreaterThan(2),
+            numOfPagesToLoad: 2,
+            duplicateMediaPossible: true,
+            timeout: 10 * 1000,
+        },
+    },
+});

package/dist/test/testFiles/sources/exampleSource.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=exampleSource.test.d.ts.map

package/dist/test/testFiles/sources/exampleSource.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exampleSource.test.d.ts","sourceRoot":"","sources":["../../../../test/testFiles/sources/exampleSource.test.ts"],"names":[],"mappings":""}

package/dist/test/testFiles/sources/exampleSource.test.js

@@ -0,0 +1,27 @@
+import { expect } from "vitest";
+import exampleSource from "../../fixtures/exampleSource.js";
+import { createBasicTestsForRequestHandlers } from "../../utils/vitest.js";
+createBasicTestsForRequestHandlers({
+    source: exampleSource,
+    queries: {
+        "single-media": {
+            request: { id: "test-getWebpage" },
+            checkResponse: (response) => expect(response).toMatchSnapshot(),
+        },
+        "search-media": {
+            request: { searchText: "search text" },
+            checkResponse: (response) => expect(response).toMatchSnapshot(),
+            numOfPagesToLoad: 3,
+            numOfPagesToExpect: 2,
+        },
+    },
+    queriesShared: {
+        finderOptions: {
+            plugins: [
+                {
+                    sources: [exampleSource],
+                },
+            ],
+        },
+    },
+});

package/dist/test/testFiles/sources/giphy.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=giphy.test.d.ts.map

package/dist/test/testFiles/sources/giphy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"giphy.test.d.ts","sourceRoot":"","sources":["../../../../test/testFiles/sources/giphy.test.ts"],"names":[],"mappings":""}

package/dist/test/testFiles/sources/giphy.test.js

@@ -0,0 +1,17 @@
+import giphySource from "../../../plugins/built-in-sources/giphy/index.js";
+import { expect } from "vitest";
+import { createBasicTestsForRequestHandlers, normaliseResponse, } from "../../utils/vitest.js";
+createBasicTestsForRequestHandlers({
+    source: giphySource,
+    queries: {
+        "single-media": {
+            request: { id: "YsTs5ltWtEhnq" },
+            checkResponse: (response) => expect(normaliseResponse(response)).toMatchSnapshot(),
+        },
+        search: {
+            request: { searchText: "happy" },
+            checkResponse: (response) => expect(response.media.length).toBeGreaterThan(5),
+            numOfPagesToLoad: 2,
+        },
+    },
+});

package/dist/test/utils/general.d.ts

@@ -0,0 +1,3 @@
+import type { GenericRequest } from "../../index.js";
+export declare function getSecrets(request: GenericRequest): Promise<any>;
+//# sourceMappingURL=general.d.ts.map

package/dist/test/utils/general.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../../../test/utils/general.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,wBAAsB,UAAU,CAAC,OAAO,EAAE,cAAc,gBAqBvD"}

package/dist/test/utils/general.js

@@ -0,0 +1,24 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+export async function getSecrets(request) {
+    try {
+        const secretsPath = process.env.LIASE_SECRETS_FILE
+            ? path.resolve(process.env.LIASE_SECRETS_FILE)
+            : path.join(import.meta.dirname, "../../.secrets.mjs");
+        try {
+            await fs.access(secretsPath);
+        }
+        catch (error) {
+            if (process.env.LIASE_SECRETS_FILE) {
+                throw Error(`LIASE_SECRETS_FILE is set to ${process.env.LIASE_SECRETS_FILE} but secrets file not found or accessible`);
+            }
+            return {};
+        }
+        const { default: importedGetSecrets } = await import(secretsPath);
+        return importedGetSecrets({ request });
+    }
+    catch (error) {
+        console.error(error);
+    }
+    return {};
+}

package/dist/test/utils/globalSetup.d.ts

@@ -0,0 +1,3 @@
+import type { GlobalSetupContext } from "vitest/node";
+export declare function vitestSetupCachingProxy(context: GlobalSetupContext): Promise<() => Promise<void>>;
+//# sourceMappingURL=globalSetup.d.ts.map

package/dist/test/utils/globalSetup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalSetup.d.ts","sourceRoot":"","sources":["../../../test/utils/globalSetup.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,gCAWxE"}

package/dist/test/utils/globalSetup.js

@@ -0,0 +1,12 @@
+import os from "node:os";
+import path from "node:path";
+import { HttpCachingProxy } from "@loopback/http-caching-proxy";
+export async function vitestSetupCachingProxy(context) {
+    const cachePath = path.join(os.tmpdir(), "liase/http-proxy-cache");
+    const proxy = new HttpCachingProxy({ cachePath });
+    await proxy.start();
+    context.provide("httpProxyUrl", proxy.url);
+    return async () => {
+        await proxy.stop();
+    };
+}