@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/modules/clay/clay.service.d.ts

@@ -0,0 +1,29 @@
+import type { z } from "zod";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { WebhookService } from "#modules/webhook/webhook.service";
+import type { ClayRepository } from "./clay.repository";
+type ClayTable = {
+    name?: string;
+    tableId?: string;
+    viewId?: string;
+    webhookUrl: string;
+    schema?: z.ZodAny;
+    timeoutInSeconds?: number;
+};
+export declare class ClayService<K extends string> extends BaseService<{
+    clay: ClayRepository;
+}, {
+    webhook: WebhookService;
+}> {
+    private tables;
+    constructor(repositories: {
+        clay: ClayRepository;
+    }, services: {
+        webhook: WebhookService;
+    }, tables: Record<K, ClayTable>);
+    waitForResponse<T>(webhookUrl: string, row: Record<string, unknown>, timeoutInSeconds?: number): ServerResultAsync<T>;
+    sendToTable(table: K, row: Record<string, unknown>, timeoutInSeconds?: number): ServerResultAsync<z.infer<(typeof this.tables)[K]["schema"] extends z.ZodAny ? z.infer<(typeof this.tables)[K]["schema"]> : unknown>>;
+}
+export {};
+//# sourceMappingURL=clay.service.d.ts.map

package/dist/src/modules/clay/clay.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clay.service.d.ts","sourceRoot":"","sources":["../../../../src/modules/clay/clay.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAExD,KAAK,SAAS,GAAG;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM,CAAE,SAAQ,WAAW,CAC5D;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,EACxB;IAAE,OAAO,EAAE,cAAc,CAAA;CAAE,CAC5B;IACC,OAAO,CAAC,MAAM,CAAuB;gBAEnC,YAAY,EAAE;QAAE,IAAI,EAAE,cAAc,CAAA;KAAE,EACtC,QAAQ,EAAE;QAAE,OAAO,EAAE,cAAc,CAAA;KAAE,EACrC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC;IAMxB,eAAe,CAAC,CAAC,EACrB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,gBAAgB,CAAC,EAAE,MAAM,GACxB,iBAAiB,CAAC,CAAC,CAAC;IAMjB,WAAW,CACf,KAAK,EAAE,CAAC,EACR,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,gBAAgB,CAAC,EAAE,MAAM,GACxB,iBAAiB,CAClB,CAAC,CAAC,KAAK,CACL,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,MAAM,GAC9C,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,GAC1C,OAAO,CACZ,CACF;CAWF"}

package/dist/src/modules/clay/clay.service.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClayService = void 0;
+const base_service_1 = require("#modules/base/base.service");
+class ClayService extends base_service_1.BaseService {
+    tables;
+    constructor(repositories, services, tables) {
+        super(repositories, services);
+        this.tables = tables;
+    }
+    async waitForResponse(webhookUrl, row, timeoutInSeconds) {
+        return await this.service.webhook.waitForRequest((url) => {
+            return this.repository.clay.sendToWebhook(webhookUrl, row, url);
+        }, timeoutInSeconds);
+    }
+    async sendToTable(table, row, timeoutInSeconds) {
+        const tableData = this.tables[table];
+        if (!tableData)
+            return this.error("NOT_FOUND", `Table ${table} not found`);
+        const response = await this.waitForResponse(tableData.webhookUrl, row, tableData.timeoutInSeconds || timeoutInSeconds);
+        return response;
+    }
+}
+exports.ClayService = ClayService;

package/dist/src/modules/connect/connect.db.d.ts

@@ -0,0 +1,357 @@
+export declare const connect: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "connect";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        userId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "user_id";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        provider: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "provider";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        accountType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "account_type";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        providerAccountId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "provider_account_id";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        handle: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "handle";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        displayName: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "display_name";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        avatarUrl: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "avatar_url";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        accessToken: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "access_token";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        refreshToken: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "refresh_token";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        tokenType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "token_type";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        scope: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "scope";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        expiresAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "expires_at";
+            tableName: "connect";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        parentId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "parent_id";
+            tableName: "connect";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        metadataJson: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "metadata_json";
+            tableName: "connect";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        revokedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "revoked_at";
+            tableName: "connect";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastRefreshedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "last_refreshed_at";
+            tableName: "connect";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "connect";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "connect";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=connect.db.d.ts.map

package/dist/src/modules/connect/connect.db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.db.d.ts","sourceRoot":"","sources":["../../../../src/modules/connect/connect.db.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BlB,CAAC"}

package/dist/src/modules/connect/connect.db.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = void 0;
+const sqlite_core_1 = require("drizzle-orm/sqlite-core");
+const uuid_1 = require("uuid");
+exports.connect = (0, sqlite_core_1.sqliteTable)("connect", {
+    id: (0, sqlite_core_1.text)("id").primaryKey().$default(uuid_1.v4),
+    userId: (0, sqlite_core_1.text)("user_id").notNull(), // FK -> users.id
+    provider: (0, sqlite_core_1.text)("provider").notNull(), // e.g. "linkedin"
+    accountType: (0, sqlite_core_1.text)("account_type").notNull(), // "user" | "page" | "org" | "channel"
+    providerAccountId: (0, sqlite_core_1.text)("provider_account_id").notNull(), // e.g. LinkedIn URN, FB Page ID, IG business acct ID, X user ID
+    handle: (0, sqlite_core_1.text)("handle"), // @name or page slug
+    displayName: (0, sqlite_core_1.text)("display_name"),
+    avatarUrl: (0, sqlite_core_1.text)("avatar_url"),
+    // OAuth credentials (ENCRYPTED)
+    accessToken: (0, sqlite_core_1.text)("access_token").notNull(),
+    refreshToken: (0, sqlite_core_1.text)("refresh_token"), // may be null if provider doesn’t issue refresh tokens
+    tokenType: (0, sqlite_core_1.text)("token_type"), // e.g. "bearer"
+    scope: (0, sqlite_core_1.text)("scope"), // space- or comma-separated list, for auditing
+    expiresAt: (0, sqlite_core_1.integer)("expires_at", { mode: "timestamp" }), // epoch seconds
+    // Provider-specific glue
+    parentId: (0, sqlite_core_1.text)("parent_id"), // e.g. FB Page’s connected IG business account, or org URN
+    metadataJson: (0, sqlite_core_1.text)("metadata_json", { mode: "json" }), // JSON string for extras (region, perms, etc.)
+    revokedAt: (0, sqlite_core_1.integer)("revoked_at", { mode: "timestamp" }),
+    lastRefreshedAt: (0, sqlite_core_1.integer)("last_refreshed_at", { mode: "timestamp" }),
+    createdAt: (0, sqlite_core_1.integer)("created_at", { mode: "timestamp" })
+        .notNull()
+        .$default(() => new Date()),
+    updatedAt: (0, sqlite_core_1.integer)("updated_at", { mode: "timestamp" }),
+});

package/dist/src/modules/connect/connect.dto.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+export declare const connectSelectSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    provider: z.ZodString;
+    accountType: z.ZodString;
+    providerAccountId: z.ZodString;
+    handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    accessToken: z.ZodString;
+    refreshToken: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tokenType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scope: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadataJson: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    revokedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    lastRefreshedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+}, z.core.$strip>;
+export type ConnectSelectSchema = z.infer<typeof connectSelectSchema>;
+export declare const connectSelectOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    provider: z.ZodString;
+    accountType: z.ZodString;
+    providerAccountId: z.ZodString;
+    handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tokenType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scope: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadataJson: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    revokedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    lastRefreshedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+}, z.core.$strip>;
+export declare const connectListInputSchema: z.ZodObject<{
+    providers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inactive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ConnectListInputSchema = z.infer<typeof connectListInputSchema>;
+export declare const connectListOutputSchema: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    userId: z.ZodString;
+    provider: z.ZodString;
+    accountType: z.ZodString;
+    providerAccountId: z.ZodString;
+    handle: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    displayName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    avatarUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tokenType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    scope: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expiresAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metadataJson: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+    revokedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    lastRefreshedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+}, z.core.$strip>>;
+export declare const connectDeleteInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare const connectDeleteOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type ConnectDeleteInputSchema = z.infer<typeof connectDeleteInputSchema>;
+export type ConnectDeleteOutputSchema = z.infer<typeof connectDeleteOutputSchema>;
+//# sourceMappingURL=connect.dto.d.ts.map

package/dist/src/modules/connect/connect.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.dto.d.ts","sourceRoot":"","sources":["../../../../src/modules/connect/connect.dto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;iBAoB9B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;iBAGpC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE5E,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;kBAAqC,CAAC;AAE1E,eAAO,MAAM,wBAAwB;;iBAA+B,CAAC;AACrE,eAAO,MAAM,yBAAyB;;iBAA+B,CAAC;AACtE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAChF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/src/modules/connect/connect.dto.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectDeleteOutputSchema = exports.connectDeleteInputSchema = exports.connectListOutputSchema = exports.connectListInputSchema = exports.connectSelectOutputSchema = exports.connectSelectSchema = void 0;
+const zod_1 = require("zod");
+exports.connectSelectSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    userId: zod_1.z.string(),
+    provider: zod_1.z.string(),
+    accountType: zod_1.z.string(),
+    providerAccountId: zod_1.z.string(),
+    handle: zod_1.z.string().nullish(),
+    displayName: zod_1.z.string().nullish(),
+    avatarUrl: zod_1.z.string().nullish(),
+    accessToken: zod_1.z.string(),
+    refreshToken: zod_1.z.string().nullish(),
+    tokenType: zod_1.z.string().nullish(),
+    scope: zod_1.z.string().nullish(),
+    expiresAt: zod_1.z.date().nullish(),
+    parentId: zod_1.z.string().nullish(),
+    metadataJson: zod_1.z.unknown().nullish(),
+    revokedAt: zod_1.z.date().nullish(),
+    lastRefreshedAt: zod_1.z.date().nullish(),
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date().nullish(),
+});
+exports.connectSelectOutputSchema = exports.connectSelectSchema.omit({
+    accessToken: true,
+    refreshToken: true,
+});
+exports.connectListInputSchema = zod_1.z.object({
+    providers: zod_1.z.array(zod_1.z.string()).optional(),
+    inactive: zod_1.z.boolean().optional(),
+});
+exports.connectListOutputSchema = zod_1.z.array(exports.connectSelectOutputSchema);
+exports.connectDeleteInputSchema = zod_1.z.object({ id: zod_1.z.string() });
+exports.connectDeleteOutputSchema = zod_1.z.object({ id: zod_1.z.string() });

package/dist/src/modules/connect/connect.linkedin.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectProvider } from "./connect.types";
+export declare function createLinkedInProvider(): ConnectProvider;
+//# sourceMappingURL=connect.linkedin.d.ts.map

package/dist/src/modules/connect/connect.linkedin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.linkedin.d.ts","sourceRoot":"","sources":["../../../../src/modules/connect/connect.linkedin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAavE,wBAAgB,sBAAsB,IAAI,eAAe,CAwDxD"}

package/dist/src/modules/connect/connect.linkedin.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinkedInProvider = createLinkedInProvider;
+function createLinkedInProvider() {
+    const clientId = process.env.LINKEDIN_CLIENT_ID;
+    const clientSecret = process.env.LINKEDIN_CLIENT_SECRET;
+    const baseUrl = process.env.VITE_SERVER_URL;
+    if (!clientId || !clientSecret || !baseUrl) {
+        throw new Error("Missing required LinkedIn OAuth environment variables: LINKEDIN_CLIENT_ID, LINKEDIN_CLIENT_SECRET, VITE_SERVER_URL");
+    }
+    return {
+        id: "linkedin",
+        clientId,
+        clientSecret,
+        redirectUri: `${baseUrl}/connect/linkedin/callback`,
+        // LinkedIn OpenID Connect scopes
+        scopes: ["openid", "profile", "w_member_social"],
+        // LinkedIn doesn't support PKCE - disable it
+        supportsPKCE: false,
+        // LinkedIn OpenID Connect endpoints
+        issuerConfig: {
+            issuer: "https://www.linkedin.com",
+            authorization_endpoint: "https://www.linkedin.com/oauth/v2/authorization",
+            token_endpoint: "https://www.linkedin.com/oauth/v2/accessToken",
+            userinfo_endpoint: "https://api.linkedin.com/v2/userinfo",
+        },
+        async mapProfile(accessToken) {
+            // Use OpenID Connect userinfo endpoint
+            const response = await fetch("https://api.linkedin.com/v2/userinfo", {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`LinkedIn API error: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            return {
+                providerAccountId: data.sub,
+                displayName: data.name,
+                avatarUrl: data.picture,
+                accountType: "user",
+                metadata: {
+                    givenName: data.given_name,
+                    familyName: data.family_name,
+                    locale: data.locale,
+                    email: data.email,
+                    emailVerified: data.email_verified,
+                },
+            };
+        },
+    };
+}

package/dist/src/modules/connect/connect.oauth.d.ts

@@ -0,0 +1,28 @@
+import * as client from "openid-client";
+import type { ConnectProvider } from "./connect.types";
+export interface OAuthState {
+    state: string;
+    codeVerifier: string;
+    codeChallenge: string;
+    sessionId: string;
+    provider: string;
+}
+export declare function generateOAuthState(sessionId: string, provider: string): Promise<OAuthState>;
+export declare function getOAuthState(sessionId: string, provider: string, state: string): OAuthState | null;
+export declare function createConfiguration(provider: ConnectProvider): Promise<client.Configuration>;
+export declare function buildAuthorizationUrl(provider: ConnectProvider, state: OAuthState): Promise<string>;
+export declare function exchangeCodeForTokens(provider: ConnectProvider, code: string, codeVerifier: string, redirectUri: string, state: string): Promise<{
+    accessToken: string;
+    refreshToken?: string;
+    tokenType?: string;
+    expiresAt?: Date;
+    scope?: string;
+}>;
+export declare function refreshAccessToken(provider: ConnectProvider, refreshToken: string): Promise<{
+    accessToken: string;
+    refreshToken?: string;
+    tokenType?: string;
+    expiresAt?: Date;
+    scope?: string;
+}>;
+//# sourceMappingURL=connect.oauth.d.ts.map

package/dist/src/modules/connect/connect.oauth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.oauth.d.ts","sourceRoot":"","sources":["../../../../src/modules/connect/connect.oauth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAYD,wBAAsB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAsBjG;AAED,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,UAAU,GAAG,IAAI,CAWnB;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,CAuC/B;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,eAAe,EACzB,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,MAAM,CAAC,CAiBjB;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;IACT,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC,CA4HD;AAED,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,eAAe,EACzB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC;IACT,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC,CAYD"}