@friggframework/api-module-frigg-scale-test 0.1.1-canary.49.1d97838.0

package/LICENSE.md

@@ -0,0 +1,16 @@
+MIT License
+
+Copyright (c) 2022 Left Hook Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/jest.config.js

@@ -0,0 +1,9 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/test'],
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  moduleNameMapper: {
+    '^services/(.*)$': '<rootDir>/../../../services/$1'
+  }
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@friggframework/api-module-frigg-scale-test",
+  "version": "0.1.1-canary.49.1d97838.0",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "jest --runInBand",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "@friggframework/core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.8.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.0",
+    "typescript": "^5.4.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "1d978381f7d76dc3cde518965e608c4db84062fa"
+}

package/src/api.ts

@@ -0,0 +1,138 @@
+export type ListParams = {
+  accountId: string;
+  limit?: number;
+  cursor?: string;
+  updatedSince?: string;
+};
+
+export type ListActivitiesParams = ListParams & {
+  type?: "phone_call" | "email" | "sms";
+  contactId?: string;
+};
+
+export class FriggScaleTestAPI {
+  constructor(readonly opts: { baseUrl?: string; apiKey?: string } = {}) {}
+
+  private get base(): string {
+    return (
+      this.opts.baseUrl ||
+      process.env.FRIGG_SCALE_TEST_BASE_URL ||
+      "http://localhost:4000"
+    );
+  }
+
+  private headers(): Record<string, string> {
+    const apiKey = this.opts.apiKey || process.env.FRIGG_SCALE_TEST_API_KEY;
+    return apiKey ? { Authorization: `Bearer ${apiKey}` } : {};
+  }
+
+  async health() {
+    const r = await fetch(new URL("/health", this.base));
+    if (!r.ok) throw new Error(`health ${r.status}`);
+    return r.json();
+  }
+
+  async getConfig(accountId: string) {
+    const r = await fetch(new URL(`/config/${encodeURIComponent(accountId)}`, this.base), {
+      headers: this.headers()
+    });
+    if (!r.ok) throw new Error(`getConfig ${r.status}`);
+    return r.json();
+  }
+
+  async putConfig(accountId: string, cfg: any) {
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      ...this.headers()
+    };
+    const r = await fetch(new URL(`/config/${encodeURIComponent(accountId)}`, this.base), {
+      method: "PUT",
+      headers,
+      body: JSON.stringify(cfg)
+    });
+    if (!r.ok) throw new Error(`putConfig ${r.status}`);
+    return r.json();
+  }
+
+  async listContacts(params: ListParams) {
+    const url = new URL(`/contacts`, this.base);
+    url.searchParams.set("accountId", params.accountId);
+    if (params.limit) url.searchParams.set("limit", String(params.limit));
+    if (params.cursor) url.searchParams.set("cursor", params.cursor);
+    if (params.updatedSince) url.searchParams.set("updatedSince", params.updatedSince);
+    const r = await fetch(url, { headers: this.headers() });
+    if (!r.ok) throw new Error(`listContacts ${r.status}`);
+    return r.json();
+  }
+
+  async listActivities(params: ListActivitiesParams) {
+    const url = new URL(`/activities`, this.base);
+    url.searchParams.set("accountId", params.accountId);
+    if (params.limit) url.searchParams.set("limit", String(params.limit));
+    if (params.cursor) url.searchParams.set("cursor", params.cursor);
+    if (params.updatedSince) url.searchParams.set("updatedSince", params.updatedSince);
+    if (params.type) url.searchParams.set("type", params.type);
+    if (params.contactId) url.searchParams.set("contactId", params.contactId);
+    const r = await fetch(url, { headers: this.headers() });
+    if (!r.ok) throw new Error(`listActivities ${r.status}`);
+    return r.json();
+  }
+
+  async createActivity(body: any) {
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      ...this.headers()
+    };
+    const r = await fetch(new URL(`/activities`, this.base), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!r.ok) throw new Error(`createActivity ${r.status}`);
+    return r.json();
+  }
+
+  async requestContactsExport(body: {
+    accountId: string;
+    format?: "ndjson" | "csv";
+    fields?: string[];
+  }) {
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      ...this.headers()
+    };
+    const r = await fetch(new URL(`/bulk/exports/contacts`, this.base), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (r.status !== 202 && r.status !== 200) throw new Error(`requestContactsExport ${r.status}`);
+    return r.json();
+  }
+
+  async requestActivitiesExport(body: {
+    accountId: string;
+    format?: "ndjson" | "csv";
+    fields?: string[];
+  }) {
+    const headers: Record<string, string> = {
+      "content-type": "application/json",
+      ...this.headers()
+    };
+    const r = await fetch(new URL(`/bulk/exports/activities`, this.base), {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (r.status !== 202 && r.status !== 200) throw new Error(`requestActivitiesExport ${r.status}`);
+    return r.json();
+  }
+
+  async getExportJob(jobId: string) {
+    const r = await fetch(new URL(`/bulk/exports/${encodeURIComponent(jobId)}`, this.base), {
+      headers: this.headers()
+    });
+    if (!r.ok) throw new Error(`getExportJob ${r.status}`);
+    return r.json();
+  }
+}

package/src/handler-proxy.d.ts

@@ -0,0 +1,4 @@
+declare module "services/frigg-scale-test-lambda/src/handler" {
+  import type { APIGatewayProxyEventV2, APIGatewayProxyResultV2 } from "aws-lambda";
+  export function handler(event: APIGatewayProxyEventV2): Promise<APIGatewayProxyResultV2>;
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+import { FriggModuleAuthDefinition } from "@friggframework/core";
+import { FriggScaleTestAPI } from "./api";
+
+export const authDef: FriggModuleAuthDefinition = {
+  API: FriggScaleTestAPI,
+  getName: () => "Frigg Scale Test (Mock CRM)",
+  moduleName: "frigg-scale-test",
+  requiredAuthMethods: {
+    apiPropertiesToPersist: { credential: ["apiKey"], entity: [] },
+    getToken: async () => undefined,
+    getEntityDetails: async (_api: FriggScaleTestAPI, params?: any) => ({
+      identifiers: { externalId: `frigg-scale-test:${params?.accountId || "default"}` },
+      details: { name: "Frigg Scale Test Mock CRM" }
+    }),
+    getCredentialDetails: async () => ({ identifiers: { externalId: "frigg-scale-test-cred" }, details: {} }),
+    testAuthRequest: async (api: FriggScaleTestAPI) => {
+      await api.health();
+    }
+  },
+  env: {
+    FRIGG_SCALE_TEST_BASE_URL: process.env.FRIGG_SCALE_TEST_BASE_URL,
+    FRIGG_SCALE_TEST_API_KEY: process.env.FRIGG_SCALE_TEST_API_KEY
+  }
+};
+
+export { FriggScaleTestAPI };
+export default authDef;

package/src/types.d.ts

@@ -0,0 +1,9 @@
+declare module "@friggframework/core" {
+  export interface FriggModuleAuthDefinition {
+    API: new (...args: any[]) => any;
+    getName: () => string;
+    moduleName: string;
+    requiredAuthMethods: Record<string, any>;
+    env?: Record<string, any>;
+  }
+}

package/test/smoke.test.ts

@@ -0,0 +1,117 @@
+import { createServer, IncomingMessage, ServerResponse } from "http";
+import { AddressInfo } from "net";
+import { handler } from "services/frigg-scale-test-lambda/src/handler";
+import { FriggScaleTestAPI } from "../src/api";
+import { APIGatewayProxyEventV2 } from "aws-lambda";
+
+let server: ReturnType<typeof createServer>;
+let baseUrl: string;
+
+function buildEvent(req: IncomingMessage, body: string): APIGatewayProxyEventV2 {
+  const url = new URL(req.url || "/", "http://localhost");
+  const headers: Record<string, string> = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (typeof value === "string") headers[key] = value;
+    if (Array.isArray(value)) headers[key] = value.join(",");
+  }
+  const query: Record<string, string> = {};
+  url.searchParams.forEach((value, key) => {
+    query[key] = value;
+  });
+  return {
+    version: "2.0",
+    routeKey: "$default",
+    rawPath: url.pathname,
+    rawQueryString: url.search.slice(1),
+    headers,
+    queryStringParameters: Object.keys(query).length ? query : null,
+    requestContext: {
+      accountId: "local",
+      apiId: "local",
+      domainName: "localhost",
+      domainPrefix: "",
+      requestId: "local",
+      routeKey: "$default",
+      stage: "$default",
+      time: new Date().toISOString(),
+      timeEpoch: Date.now(),
+      http: {
+        method: req.method || "GET",
+        path: url.pathname,
+        protocol: "HTTP/1.1",
+        sourceIp: "127.0.0.1",
+        userAgent: "jest"
+      }
+    },
+    isBase64Encoded: false,
+    body: body || undefined,
+    pathParameters: null,
+    stageVariables: null,
+    cookies: [],
+    multiValueQueryStringParameters: null
+  } as unknown as APIGatewayProxyEventV2;
+}
+
+function ensureStructured(result: Awaited<ReturnType<typeof handler>>) {
+  if (typeof result === "string") {
+    return { statusCode: 200, headers: {}, body: result } as const;
+  }
+  return result;
+}
+
+beforeAll(async () => {
+  server = createServer((req: IncomingMessage, res: ServerResponse) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk: Buffer) => chunks.push(chunk));
+    req.on("end", async () => {
+      const body = Buffer.concat(chunks).toString();
+      try {
+        const event = buildEvent(req, body);
+        const result = ensureStructured(await handler(event));
+        res.statusCode = result.statusCode || 200;
+        for (const [key, value] of Object.entries(result.headers || {})) {
+          if (value !== undefined) {
+            res.setHeader(key, value as string);
+          }
+        }
+        res.end(result.body || "");
+      } catch (err: any) {
+        res.statusCode = 500;
+        res.end(JSON.stringify({ error: err?.message || "error" }));
+      }
+    });
+  });
+
+  await new Promise<void>((resolve) => {
+    server.listen(0, () => resolve());
+  });
+  const address = server.address() as AddressInfo;
+  baseUrl = `http://127.0.0.1:${address.port}`;
+  process.env.FRIGG_SCALE_TEST_BASE_URL = baseUrl;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+});
+
+const api = new FriggScaleTestAPI();
+
+describe("Frigg Scale Test Mock CRM", () => {
+  it("health", async () => {
+    const health = await api.health();
+    expect(health.ok).toBeTruthy();
+  });
+
+  it("contacts pagination", async () => {
+    const page = await api.listContacts({ accountId: "demo", limit: 10 });
+    expect(Array.isArray(page.items)).toBe(true);
+    expect(page.items.length).toBeLessThanOrEqual(10);
+  });
+
+  it("activities list and create", async () => {
+    const list = await api.listActivities({ accountId: "demo", limit: 5, type: "email" });
+    expect(Array.isArray(list.items)).toBe(true);
+    const created = await api.createActivity({ accountId: "demo", type: "sms", contactId: "contact-1", subject: "Ping" });
+    expect(created.id).toBeTruthy();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "module": "commonjs",
+    "target": "ES2020",
+    "esModuleInterop": true,
+    "strict": true,
+    "baseUrl": ".",
+    "paths": {
+      "services/*": ["../../../services/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["dist", "test"]
+}