@friggframework/api-module-frigg-scale-test 0.1.1-canary.50.12ea60a.0 → 0.2.0-next.0

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

@@ -1,20 +1,14 @@
 {
   "name": "@friggframework/api-module-frigg-scale-test",
-  "version": "0.1.1-canary.50.12ea60a.0",
+  "version": "0.2.0-next.0",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "prepare": "npm run build",
     "test": "jest --runInBand",
     "lint": "eslint ."
   },
-  "files": [
-    "dist/**/*",
-    "README.md",
-    "LICENSE"
-  ],
   "dependencies": {
     "@friggframework/core": "^1.0.0"
   },
@@ -28,5 +22,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "12ea60ac1e9b86b7c5e9368165aac64fa39130d3"
+  "gitHead": "65e73334219f8e50b565dbdf5dee0455ac568920"
 }

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"]
+}

package/dist/api.d.ts

@@ -1,39 +0,0 @@
-export type ListParams = {
-    accountId: string;
-    limit?: number;
-    cursor?: string;
-    updatedSince?: string;
-};
-export type ListActivitiesParams = ListParams & {
-    type?: "phone_call" | "email" | "sms";
-    contactId?: string;
-};
-export default class FriggScaleTestAPI {
-    readonly opts: {
-        baseUrl?: string;
-        apiKey?: string;
-    };
-    constructor(opts?: {
-        baseUrl?: string;
-        apiKey?: string;
-    });
-    private get base();
-    private headers;
-    health(): Promise<any>;
-    getConfig(accountId: string): Promise<any>;
-    putConfig(accountId: string, cfg: any): Promise<any>;
-    listContacts(params: ListParams): Promise<any>;
-    listActivities(params: ListActivitiesParams): Promise<any>;
-    createActivity(body: any): Promise<any>;
-    requestContactsExport(body: {
-        accountId: string;
-        format?: "ndjson" | "csv";
-        fields?: string[];
-    }): Promise<any>;
-    requestActivitiesExport(body: {
-        accountId: string;
-        format?: "ndjson" | "csv";
-        fields?: string[];
-    }): Promise<any>;
-    getExportJob(jobId: string): Promise<any>;
-}

package/dist/api.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class FriggScaleTestAPI {
-    constructor(opts = {}) {
-        this.opts = opts;
-    }
-    get base() {
-        return (this.opts.baseUrl ||
-            process.env.FRIGG_SCALE_TEST_BASE_URL ||
-            "http://localhost:4000");
-    }
-    headers() {
-        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) {
-        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, cfg) {
-        const headers = {
-            "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) {
-        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) {
-        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) {
-        const headers = {
-            "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) {
-        const headers = {
-            "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) {
-        const headers = {
-            "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) {
-        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();
-    }
-}
-exports.default = FriggScaleTestAPI;

package/dist/defintion.d.ts

@@ -1,3 +0,0 @@
-import { FriggModuleAuthDefinition } from "@friggframework/core";
-declare const definition: FriggModuleAuthDefinition;
-export default definition;

package/dist/defintion.js

@@ -1,49 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const api_1 = __importDefault(require("./api"));
-const definition = {
-    API: api_1.default,
-    getName: () => "Frgg Scale Test API",
-    moduleName: "scale-test",
-    requiredAuthMethods: {
-        getToken: async (api, params) => {
-            // For scale test API, use API key authentication
-            const apiKey = params.data?.apiKey || params.data?.access_token;
-            return { access_token: apiKey };
-        },
-        getEntityDetails: async (api, callbackParams, tokenResponse, userId) => {
-            const healthCheck = await api.health();
-            return {
-                identifiers: {
-                    externalId: "scale-test-account",
-                    user: userId,
-                },
-                details: {
-                    name: "Scale Test Account",
-                    status: healthCheck.ok ? "healthy" : "error",
-                },
-            };
-        },
-        apiPropertiesToPersist: {
-            credential: ["access_token"],
-            entity: [],
-        },
-        getCredentialDetails: async (api, userId) => {
-            return {
-                identifiers: {
-                    externalId: "scale-test-account",
-                    user: userId,
-                },
-                details: {},
-            };
-        },
-        testAuthRequest: async (api) => api.health(),
-    },
-    env: {
-        apiKey: process.env.SCALE_TEST_API_KEY,
-    },
-};
-exports.default = definition;

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-import FriggScaleTestAPI from "./api";
-import Definition from "./defintion";
-export { FriggScaleTestAPI, Definition };

package/dist/index.js

@@ -1,10 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Definition = exports.FriggScaleTestAPI = void 0;
-const api_1 = __importDefault(require("./api"));
-exports.FriggScaleTestAPI = api_1.default;
-const defintion_1 = __importDefault(require("./defintion"));
-exports.Definition = defintion_1.default;