@m5kdev/backend 0.5.0 → 0.7.0

package/dist/src/modules/base/base.service.test.js

@@ -0,0 +1,443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const neverthrow_1 = require("neverthrow");
+const errors_1 = require("../../utils/errors");
+const base_actor_1 = require("./base.actor");
+const base_service_1 = require("./base.service");
+function createActor(overrides = {}) {
+    const actor = (0, base_actor_1.createServiceActor)({
+        userId: "user-1",
+        userRole: "member",
+        organizationId: null,
+        organizationRole: null,
+        teamId: null,
+        teamRole: null,
+        ...overrides,
+    });
+    if (!actor) {
+        throw new Error("Expected actor");
+    }
+    return actor;
+}
+function createOrganizationActor(overrides = {}) {
+    return createActor({
+        organizationId: "org-1",
+        organizationRole: "owner",
+        ...overrides,
+    });
+}
+function createTeamActor(overrides = {}) {
+    return createActor({
+        organizationId: "org-1",
+        organizationRole: "owner",
+        teamId: "team-1",
+        teamRole: "member",
+        ...overrides,
+    });
+}
+describe("BaseService procedure builder", () => {
+    it("runs chained steps in order and exposes state by step name", async () => {
+        const events = [];
+        class PipelineService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .use("trimmed", ({ input }) => {
+                events.push("trimmed");
+                return input.value.trim();
+            })
+                .use("upper", ({ state }) => {
+                events.push("upper");
+                return state.trimmed.toUpperCase();
+            })
+                .handle(({ state }) => {
+                events.push("handler");
+                return (0, neverthrow_1.ok)({
+                    trimmed: state.trimmed,
+                    upper: state.upper,
+                });
+            });
+        }
+        const service = new PipelineService();
+        const result = await service.run({ value: "  hello  " }, {});
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value).toEqual({
+                trimmed: "hello",
+                upper: "HELLO",
+            });
+        }
+        expect(events).toEqual(["trimmed", "upper", "handler"]);
+    });
+    it("addContextFilter wraps auth and maps query input with the default step name", async () => {
+        class QueryService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .addContextFilter(["user", "organization"])
+                .handle(({ input, state }) => (0, neverthrow_1.ok)({
+                input,
+                stateMatches: state.contextFilter === input,
+            }));
+        }
+        const service = new QueryService();
+        const unauthorized = await service.run({ search: "hello" }, {});
+        expect(unauthorized.isErr()).toBe(true);
+        if (unauthorized.isErr()) {
+            expect(unauthorized.error.code).toBe("UNAUTHORIZED");
+        }
+        const authorized = await service.run({ search: "hello" }, {
+            actor: createOrganizationActor(),
+        });
+        expect(authorized.isOk()).toBe(true);
+        if (authorized.isOk()) {
+            expect(authorized.value.input.search).toBe("hello");
+            expect(authorized.value.stateMatches).toBe(true);
+            expect(authorized.value.input.filters).toEqual([
+                {
+                    columnId: "userId",
+                    type: "string",
+                    method: "equals",
+                    value: "user-1",
+                },
+                {
+                    columnId: "organizationId",
+                    type: "string",
+                    method: "equals",
+                    value: "org-1",
+                },
+            ]);
+        }
+    });
+    it("addContextFilter returns FORBIDDEN when the actor scope is too small", async () => {
+        class QueryService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .addContextFilter(["organization"])
+                .handle(({ input }) => (0, neverthrow_1.ok)(input));
+        }
+        const service = new QueryService();
+        const result = await service.run({ search: "hello" }, {
+            actor: createActor(),
+        });
+        expect(result.isErr()).toBe(true);
+        if (result.isErr()) {
+            expect(result.error.code).toBe("FORBIDDEN");
+        }
+    });
+    it("mapInput updates the input seen by later steps and the handler", async () => {
+        class QueryService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .requireAuth()
+                .mapInput("scopedQuery", ({ input, ctx }) => this.addContextFilter(ctx.actor, { user: true, organization: true, team: true }, input, {
+                userId: {
+                    columnId: "authorUserId",
+                    method: "equals",
+                },
+                organizationId: {
+                    columnId: "organizationId",
+                    method: "equals",
+                },
+                teamId: {
+                    columnId: "teamId",
+                    method: "equals",
+                },
+            }))
+                .use("filterCount", ({ input }) => input.filters?.length ?? 0)
+                .handle(({ input, state }) => (0, neverthrow_1.ok)({
+                input,
+                filterCount: state.filterCount,
+                scopedInputMatches: state.scopedQuery === input,
+            }));
+        }
+        const service = new QueryService();
+        const result = await service.run({ search: "hello" }, {
+            actor: createTeamActor(),
+        });
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value.input.search).toBe("hello");
+            expect(result.value.filterCount).toBe(3);
+            expect(result.value.scopedInputMatches).toBe(true);
+            expect(result.value.input.filters).toEqual([
+                {
+                    columnId: "authorUserId",
+                    type: "string",
+                    method: "equals",
+                    value: "user-1",
+                },
+                {
+                    columnId: "organizationId",
+                    type: "string",
+                    method: "equals",
+                    value: "org-1",
+                },
+                {
+                    columnId: "teamId",
+                    type: "string",
+                    method: "equals",
+                    value: "team-1",
+                },
+            ]);
+        }
+    });
+    it("uses the base service default context type for procedures", async () => {
+        class ContextService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .requireAuth()
+                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.requestId}:${ctx.actor.userId}:${input.value}`));
+        }
+        const service = new ContextService();
+        const result = await service.run({ value: "ok" }, {
+            requestId: "req-1",
+            actor: createActor(),
+        });
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value).toBe("req-1:user-1:ok");
+        }
+    });
+    it("requireAuth rejects missing auth context", async () => {
+        class ProtectedService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .requireAuth()
+                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.actor.userId}:${input.value}`));
+        }
+        const service = new ProtectedService();
+        const result = await service.run({ value: "x" }, {});
+        expect(result.isErr()).toBe(true);
+        if (result.isErr()) {
+            expect(result.error.code).toBe("UNAUTHORIZED");
+        }
+    });
+    it("requireAuth allows valid context", async () => {
+        class ProtectedService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .requireAuth()
+                .handle(({ input, ctx }) => (0, neverthrow_1.ok)(`${ctx.actor.userId}:${input.value}`));
+        }
+        const service = new ProtectedService();
+        const result = await service.run({ value: "ok" }, { actor: createActor() });
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value).toBe("user-1:ok");
+        }
+    });
+    it("requireAuth accepts organization actors for organization scope", async () => {
+        class ProtectedService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .requireAuth("organization")
+                .handle(({ ctx }) => (0, neverthrow_1.ok)(ctx.actor.organizationId));
+        }
+        const service = new ProtectedService();
+        const result = await service.run(undefined, {
+            actor: createOrganizationActor(),
+        });
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value).toBe("org-1");
+        }
+    });
+    it("requireAuth rejects actors without the requested team scope", async () => {
+        class ProtectedService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .requireAuth("team")
+                .handle(({ ctx }) => (0, neverthrow_1.ok)(ctx.actor.teamId));
+        }
+        const service = new ProtectedService();
+        const result = await service.run(undefined, {
+            actor: createOrganizationActor(),
+        });
+        expect(result.isErr()).toBe(true);
+        if (result.isErr()) {
+            expect(result.error.code).toBe("FORBIDDEN");
+        }
+    });
+    it("normalizes thrown async errors through throwableAsync", async () => {
+        class ThrowingService extends base_service_1.BaseService {
+            run = this.procedure("run").handle(async () => {
+                throw new Error("boom");
+            });
+        }
+        const service = new ThrowingService();
+        const result = await service.run(undefined, {});
+        expect(result.isErr()).toBe(true);
+        if (result.isErr()) {
+            expect(result.error.code).toBe("INTERNAL_SERVER_ERROR");
+            expect(result.error.cause).toBeInstanceOf(Error);
+        }
+    });
+    it("logs metadata stages without input or context payloads", async () => {
+        class LoggedService extends base_service_1.BaseService {
+            run = this.procedure("run")
+                .requireAuth()
+                .handle(({ ctx }) => (0, neverthrow_1.ok)(ctx.actor.userId));
+        }
+        const service = new LoggedService();
+        const debugSpy = jest.fn();
+        service.logger.debug = debugSpy;
+        const result = await service.run({ secret: "top-secret" }, {
+            actor: createActor(),
+            token: "super-token",
+        });
+        expect(result.isOk()).toBe(true);
+        expect(debugSpy).toHaveBeenCalledTimes(3);
+        const payloads = debugSpy.mock.calls.map(([payload]) => payload);
+        expect(payloads.map((payload) => payload.stage)).toEqual(["start", "auth_passed", "success"]);
+        const serializedPayloads = JSON.stringify(payloads);
+        expect(serializedPayloads).not.toContain("top-secret");
+        expect(serializedPayloads).not.toContain("super-token");
+        expect(payloads.every((payload) => "hasActor" in payload)).toBe(true);
+        expect(payloads.every((payload) => !("input" in payload))).toBe(true);
+        expect(payloads.every((payload) => !("ctx" in payload))).toBe(true);
+    });
+});
+describe("BasePermissionService procedure builder", () => {
+    it("passes loaded entities into the handler when access is granted", async () => {
+        const grants = [
+            {
+                action: "read",
+                level: "user",
+                role: "member",
+                access: "own",
+            },
+        ];
+        class PermissionService extends base_service_1.BasePermissionService {
+            constructor() {
+                super({}, {}, grants);
+            }
+            run = this.procedure("run")
+                .access({
+                action: "read",
+                entities: ({ input }) => ({
+                    userId: input.ownerId,
+                }),
+            })
+                .handle(({ state }) => (0, neverthrow_1.ok)(state.access?.userId ?? null));
+        }
+        const service = new PermissionService();
+        const result = await service.run({ ownerId: "user-1" }, { actor: createActor() });
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value).toBe("user-1");
+        }
+    });
+    it("reuses a typed state step directly when entityStep is provided", async () => {
+        const grants = [
+            {
+                action: "read",
+                level: "user",
+                role: "member",
+                access: "own",
+            },
+        ];
+        class PermissionService extends base_service_1.BasePermissionService {
+            constructor() {
+                super({}, {}, grants);
+            }
+            run = this.procedure("run")
+                .use("record", ({ input }) => (0, neverthrow_1.ok)({
+                id: "resource-1",
+                userId: input.ownerId,
+                teamId: null,
+                organizationId: null,
+            }))
+                .access({
+                action: "read",
+                entityStep: "record",
+            })
+                .handle(({ state }) => (0, neverthrow_1.ok)(state.access === state.record));
+        }
+        const service = new PermissionService();
+        const result = await service.run({ ownerId: "user-1" }, { actor: createActor() });
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value).toBe(true);
+        }
+    });
+    it("returns FORBIDDEN when access validation fails", async () => {
+        const grants = [
+            {
+                action: "read",
+                level: "user",
+                role: "member",
+                access: "own",
+            },
+        ];
+        class PermissionService extends base_service_1.BasePermissionService {
+            constructor() {
+                super({}, {}, grants);
+            }
+            run = this.procedure("run")
+                .access({
+                action: "read",
+                entities: ({ input }) => ({
+                    userId: input.ownerId,
+                }),
+            })
+                .handle(() => (0, neverthrow_1.ok)("allowed"));
+        }
+        const service = new PermissionService();
+        const result = await service.run({ ownerId: "other-user" }, { actor: createActor() });
+        expect(result.isErr()).toBe(true);
+        if (result.isErr()) {
+            expect(result.error.code).toBe("FORBIDDEN");
+        }
+    });
+    it("propagates entity loader failures through access", async () => {
+        const grants = [
+            {
+                action: "read",
+                level: "user",
+                role: "member",
+                access: "own",
+            },
+        ];
+        class PermissionService extends base_service_1.BasePermissionService {
+            constructor() {
+                super({}, {}, grants);
+            }
+            run = this.procedure("run")
+                .access({
+                action: "read",
+                entities: async () => (0, neverthrow_1.err)(new errors_1.ServerError({
+                    code: "NOT_FOUND",
+                    layer: "service",
+                    layerName: "PermissionService",
+                    message: "Missing entity",
+                })),
+            })
+                .handle(() => (0, neverthrow_1.ok)("allowed"));
+        }
+        const service = new PermissionService();
+        const result = await service.run({ ownerId: "user-1" }, { actor: createActor() });
+        expect(result.isErr()).toBe(true);
+        if (result.isErr()) {
+            expect(result.error.code).toBe("INTERNAL_SERVER_ERROR");
+        }
+    });
+    it("skips entity loading when grants already allow all access", async () => {
+        const grants = [
+            {
+                action: "read",
+                level: "user",
+                role: "member",
+                access: "all",
+            },
+        ];
+        const resolveEntity = jest.fn(async () => ({ userId: "user-1" }));
+        class PermissionService extends base_service_1.BasePermissionService {
+            constructor() {
+                super({}, {}, grants);
+            }
+            run = this.procedure("run")
+                .access({
+                action: "read",
+                entities: resolveEntity,
+            })
+                .handle(() => (0, neverthrow_1.ok)("allowed"));
+        }
+        const service = new PermissionService();
+        const result = await service.run({ ownerId: "other-user" }, { actor: createActor() });
+        expect(result.isOk()).toBe(true);
+        if (result.isOk()) {
+            expect(result.value).toBe("allowed");
+        }
+        expect(resolveEntity).not.toHaveBeenCalled();
+    });
+});

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

@@ -1,6 +1,8 @@
+import type { BillingSchema } from "@m5kdev/commons/modules/billing/billing.schema";
 import type Stripe from "stripe";
 import type { User } from "../auth/auth.lib";
 import type { ServerResult, ServerResultAsync } from "../base/base.dto";
+import type { Context } from "../../utils/trpc";
 import { BaseService } from "../base/base.service";
 import type { BillingRepository } from "./billing.repository";
 export declare class BillingService extends BaseService<{
@@ -20,31 +22,8 @@ export declare class BillingService extends BaseService<{
             name?: string;
         };
     }): ServerResultAsync<boolean>;
-    getActiveSubscription({ user }: {
-        user: User;
-    }): Promise<ServerResult<{
-        id: string;
-        plan: string;
-        referenceId: string;
-        status: string;
-        stripeCustomerId?: string | null | undefined;
-        stripeSubscriptionId?: string | null | undefined;
-        periodStart?: Date | null | undefined;
-        periodEnd?: Date | null | undefined;
-        cancelAtPeriodEnd?: boolean | null | undefined;
-        cancelAt?: Date | null | undefined;
-        canceledAt?: Date | null | undefined;
-        seats?: number | null | undefined;
-        trialStart?: Date | null | undefined;
-        trialEnd?: Date | null | undefined;
-        priceId?: string | null | undefined;
-        interval?: string | null | undefined;
-        unitAmount?: number | null | undefined;
-        discounts?: string[] | null | undefined;
-    } | null>>;
-    listInvoices({ user }: {
-        user: User;
-    }): ServerResultAsync<Stripe.Invoice[]>;
+    getActiveSubscription(ctx: Context): ServerResultAsync<BillingSchema | null>;
+    listInvoices(ctx: Context): ServerResultAsync<Stripe.Invoice[]>;
     createCheckoutSession({ priceId }: {
         priceId: string;
     }, { user }: {

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BillingService = void 0;
 const neverthrow_1 = require("neverthrow");
-const base_service_1 = require("../base/base.service");
 const posthog_1 = require("../../utils/posthog");
+const base_service_1 = require("../base/base.service");
 const allowedEvents = [
     "checkout.session.completed",
     "customer.subscription.created",
@@ -72,13 +72,13 @@ class BillingService extends base_service_1.BaseService {
         }
         return (0, neverthrow_1.ok)(true);
     }
-    async getActiveSubscription({ user }) {
-        return this.repository.billing.getActiveSubscription(user.id);
+    async getActiveSubscription(ctx) {
+        return this.repository.billing.getActiveSubscription(ctx.actor.userId);
     }
-    async listInvoices({ user }) {
-        if (!user.stripeCustomerId)
+    async listInvoices(ctx) {
+        if (!ctx.user.stripeCustomerId)
             return this.error("NOT_FOUND", "User has no stripe customer id");
-        return this.repository.billing.listInvoices(user.stripeCustomerId);
+        return this.repository.billing.listInvoices(ctx.user.stripeCustomerId);
     }
     async createCheckoutSession({ priceId }, { user }) {
         let stripeCustomerId = user.stripeCustomerId;

package/dist/src/modules/billing/billing.trpc.d.ts

@@ -1,7 +1,7 @@
-import type { BillingService } from "./billing.service";
 import { type TRPCMethods } from "../../utils/trpc";
+import type { BillingService } from "./billing.service";
 export declare function createBillingTRPC({ router, privateProcedure: procedure }: TRPCMethods, billingService: BillingService): import("@trpc/server").TRPCBuiltRouter<{
-    ctx: import("../auth/auth.lib").Context;
+    ctx: import("../../utils/trpc").Context;
     meta: any;
     errorShape: import("@trpc/server").TRPCDefaultErrorShape;
     transformer: true;

package/dist/src/modules/billing/billing.trpc.js

@@ -5,13 +5,11 @@ const billing_schema_1 = require("@m5kdev/commons/modules/billing/billing.schema
 const trpc_1 = require("../../utils/trpc");
 function createBillingTRPC({ router, privateProcedure: procedure }, billingService) {
     return router({
-        getActiveSubscription: procedure
-            .output(billing_schema_1.billingSchema.nullable())
-            .query(async ({ ctx: { user } }) => {
-            return (0, trpc_1.handleTRPCResult)(await billingService.getActiveSubscription({ user }));
+        getActiveSubscription: procedure.output(billing_schema_1.billingSchema.nullable()).query(async ({ ctx }) => {
+            return (0, trpc_1.handleTRPCResult)(await billingService.getActiveSubscription(ctx));
         }),
-        listInvoices: procedure.query(async ({ ctx: { user } }) => {
-            return (0, trpc_1.handleTRPCResult)(await billingService.listInvoices({ user }));
+        listInvoices: procedure.query(async ({ ctx }) => {
+            return (0, trpc_1.handleTRPCResult)(await billingService.listInvoices(ctx));
         }),
     });
 }

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

@@ -389,22 +389,22 @@ export declare class ConnectRepository extends BaseTableRepository<Orm, Schema,
         updatedAt: Date | null;
     }[]>>;
     upsert(data: ConnectInsert, tx?: Orm): Promise<import("../base/base.dto").ServerResult<{
-        provider: string;
         id: string;
         createdAt: Date;
         updatedAt: Date | null;
-        userId: string;
         expiresAt: Date | null;
+        userId: string;
+        parentId: string | null;
         accessToken: string;
         refreshToken: string | null;
         scope: string | null;
+        provider: string;
         accountType: string;
         providerAccountId: string;
         handle: string | null;
         displayName: string | null;
         avatarUrl: string | null;
         tokenType: string | null;
-        parentId: string | null;
         metadataJson: unknown;
         revokedAt: Date | null;
         lastRefreshedAt: Date | null;

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

@@ -1,7 +1,6 @@
 import type { User } from "../auth/auth.lib";
 import type { ServerResultAsync } from "../base/base.dto";
 import { BaseService } from "../base/base.service";
-import type { ConnectDeleteInputSchema, ConnectListInputSchema } from "./connect.dto";
 import type { ConnectRepository } from "./connect.repository";
 import type { ConnectProvider } from "./connect.types";
 export declare class ConnectService extends BaseService<{
@@ -16,15 +15,15 @@ export declare class ConnectService extends BaseService<{
         url: string;
     }>;
     handleCallback(user: User, sessionId: string, providerId: string, code: string, state: string): Promise<import("../base/base.dto").ServerResult<{
-        provider: string;
         id: string;
         createdAt: Date;
         updatedAt: Date | null;
-        userId: string;
         expiresAt: Date | null;
+        userId: string;
         accessToken: string;
         refreshToken: string | null;
         scope: string | null;
+        provider: string;
         accountType: string;
         providerAccountId: string;
         handle: string | null;
@@ -37,15 +36,15 @@ export declare class ConnectService extends BaseService<{
         lastRefreshedAt: Date | null;
     }>>;
     refreshToken(connectionId: string): Promise<import("../base/base.dto").ServerResult<{
-        provider: string;
         id: string;
         createdAt: Date;
         updatedAt: Date | null;
-        userId: string;
         expiresAt: Date | null;
+        userId: string;
         accessToken: string;
         refreshToken: string | null;
         scope: string | null;
+        provider: string;
         accountType: string;
         providerAccountId: string;
         handle: string | null;
@@ -57,9 +56,14 @@ export declare class ConnectService extends BaseService<{
         revokedAt: Date | null;
         lastRefreshedAt: Date | null;
     }>>;
-    list(input: ConnectListInputSchema, { user }: {
-        user: User;
-    }): Promise<import("../base/base.dto").ServerResult<{
+    readonly list: import("../base/base.procedure").ServiceProcedure<{
+        providers?: string[] | undefined;
+        inactive?: boolean | undefined;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
         id: string;
         userId: string;
         provider: string;
@@ -79,10 +83,14 @@ export declare class ConnectService extends BaseService<{
         lastRefreshedAt: Date | null;
         createdAt: Date;
         updatedAt: Date | null;
-    }[]>>;
-    delete({ id }: ConnectDeleteInputSchema, { user }: {
-        user: User;
-    }): Promise<import("../base/base.dto").ServerResult<{
+    }[]>;
+    readonly delete: import("../base/base.procedure").ServiceProcedure<{
         id: string;
-    }>>;
+    }, {
+        actor?: import("../base/base.actor").AuthenticatedActor | null;
+    } & Record<string, unknown> & {
+        actor: import("../base/base.actor").UserActor;
+    }, {
+        id: string;
+    }>;
 }

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

@@ -97,18 +97,20 @@ class ConnectService extends base_service_1.BaseService {
             return (0, neverthrow_1.ok)(updated.value);
         });
     }
-    async list(input, { user }) {
-        return this.repository.connect.list({ userId: user.id, ...input });
-    }
-    async delete({ id }, { user }) {
-        const connection = await this.repository.connect.findById(id);
+    list = this.procedure("connectList")
+        .requireAuth()
+        .handle(({ input, ctx }) => this.repository.connect.list({ userId: ctx.actor.userId, ...input }));
+    delete = this.procedure("connectDelete")
+        .requireAuth()
+        .handle(async ({ input, ctx }) => {
+        const connection = await this.repository.connect.findById(input.id);
         if (connection.isOk()) {
-            if (connection.value?.userId !== user.id) {
+            if (connection.value?.userId !== ctx.actor.userId) {
                 return this.error("FORBIDDEN", "Not your connection");
             }
-            return this.repository.connect.deleteById(id);
+            return this.repository.connect.deleteById(input.id);
         }
         return (0, neverthrow_1.err)(connection.error);
-    }
+    });
 }
 exports.ConnectService = ConnectService;