@roadmanjs/chat 0.0.63 → 0.0.64

package/src/chat/models/ChatUser.model.ts

@@ -0,0 +1,67 @@
+import {Field, ObjectType} from 'couchset';
+
+/**
+ * GraphQL Types start
+ */
+
+@ObjectType('ChatUserType')
+export class ChatUserType {
+    @Field(() => String, {nullable: true})
+    id?: string;
+
+    @Field(() => String, {nullable: true})
+    email?: string;
+
+    @Field(() => String, {nullable: true})
+    username?: string;
+
+    @Field(() => String, {nullable: true})
+    fullname?: string;
+
+    @Field(() => String, {nullable: true})
+    firstname?: string;
+
+    @Field(() => String, {nullable: true})
+    lastname?: string;
+
+    @Field(() => String, {nullable: true})
+    phone?: string;
+
+    @Field(() => String, {nullable: true})
+    website?: string;
+
+    @Field(() => String, {nullable: true})
+    address?: string;
+
+    @Field(() => String, {nullable: true})
+    country?: string;
+
+    @Field(() => String, {nullable: true})
+    bio?: string;
+
+    @Field(() => String, {nullable: true})
+    avatar?: string;
+
+    // Wallet here
+    @Field(() => String, {nullable: true})
+    currency?: string;
+
+    @Field(() => Number, {nullable: true})
+    balance?: number;
+
+    @Field(() => Boolean, {nullable: true})
+    admin?: boolean;
+
+    @Field(() => [String], {nullable: true})
+    plans?: string[];
+
+    // Revoke accessToken
+    @Field(() => Number, {nullable: true})
+    tokenVersion?: number;
+
+    @Field(() => Date, {nullable: true})
+    createdAt?: Date;
+
+    @Field(() => Date, {nullable: true})
+    updatedAt?: Date;
+}

package/src/chat/models/chat.txt

@@ -0,0 +1,17 @@
+SELECT *
+FROM `dev` convo 
+   INNER NEST `dev` members
+   ON KEYS convo.members
+   INNER NEST `dev` owner
+   ON KEYS convo.owner
+WHERE convo._type = "ChatConvo"
+LIMIT 1;
+
+SELECT *
+FROM `dev` convo 
+   INNER NEST `dev` chatConvo
+   ON KEYS convo.chatConvoId
+   INNER NEST `dev` owner
+   ON KEYS convo.owner
+WHERE convo._type = "ChatConvoUser"
+LIMIT 1;

package/src/chat/models/index.ts

@@ -0,0 +1,3 @@
+export * from './ChatAttachment.model';
+export * from './ChatConvo.model';
+export * from './ChatMessage.model';

package/src/chat/mutations/chatConvo.mutation.ts

@@ -0,0 +1,20 @@
+import {ChatResTypeFragment} from '../fragments/resType';
+import gql from 'graphql-tag';
+
+export const CREATE_CHAT_CONVO_MUTATION = gql`
+    mutation CreateChatConvo($args: ChatConvoInput!) {
+        data: createChatConvo(args: $args) {
+            ...ChatResTypeFragment
+        }
+    }
+    ${ChatResTypeFragment}
+`;
+
+export const START_CHAT_CONVO_MUTATIONS = gql`
+    mutation StartChatConvo($args: ChatConvoInput!) {
+        data: startConvo(args: $args) {
+            ...ChatResTypeFragment
+        }
+    }
+    ${ChatResTypeFragment}
+`;

package/src/chat/mutations/chatMessage.mutation.ts

@@ -0,0 +1,11 @@
+import {ChatResTypeFragment} from '../fragments/resType';
+import gql from 'graphql-tag';
+
+export const CREATE_CHAT_MESSAGE_MUTATION = gql`
+    mutation CreateChatMessage($args: ChatMessageInput!) {
+        data: createChatMessage(args: $args) {
+            ...ChatResTypeFragment
+        }
+    }
+    ${ChatResTypeFragment}
+`;

package/src/chat/mutations/index.ts

@@ -0,0 +1,2 @@
+export * from './chatConvo.mutation';
+export * from './chatMessage.mutation';

package/src/chat/query/README.md

@@ -0,0 +1 @@
+# Only for client query graphql-tagss

package/src/chat/query/chatConvo.query.ts

@@ -0,0 +1,33 @@
+import {ChatConvoFragment} from '../fragments/chatConvo.fragment';
+import gql from 'graphql-tag';
+
+export const GET_CHAT_CONVO = gql`
+    query GetChatConvo($owner: String!, $before: DateTime, $after: DateTime, $limit: Float) {
+        data: chatConvo(owner: $owner, before: $before, after: $after, limit: $limit) {
+            items {
+                ...ChatConvoFragment
+            }
+            hasNext
+            params
+        }
+    }
+    ${ChatConvoFragment}
+`;
+
+export const GET_CHAT_CONVO_BY_ID = gql`
+    query GetChatConvoById($id: String!) {
+        data: chatConvoById(id: $id) {
+            ...ChatConvoFragment
+        }
+    }
+    ${ChatConvoFragment}
+`;
+
+export const GET_CHAT_CONVO_PUBLIC_BY_ID = gql`
+    query GetChatConvoPublicById($id: String!) {
+        data: chatConvoPublicById(id: $id) {
+            ...ChatConvoFragment
+        }
+    }
+    ${ChatConvoFragment}
+`;

package/src/chat/query/chatMessage.query.ts

@@ -0,0 +1,21 @@
+import {ChatMessageFragment} from '../fragments/chatMessage.fragment';
+import gql from 'graphql-tag';
+
+export const CHAT_TYPING = gql`
+    query ChatTyping($convoId: String!, $time: DateTime) {
+        data: chatTyping(convoId: $convoId, time: $time)
+    }
+`;
+
+export const GET_CHAT_MESSAGE = gql`
+    query GetChatMessage($convoId: String!, $before: DateTime, $after: DateTime, $limit: Float) {
+        data: chatMessage(convoId: $convoId, before: $before, after: $after, limit: $limit) {
+            items {
+                ...ChatMessageFragment
+            }
+            hasNext
+            params
+        }
+    }
+    ${ChatMessageFragment}
+`;

package/src/chat/query/index.ts

@@ -0,0 +1,2 @@
+export * from './chatConvo.query';
+export * from './chatMessage.query';

package/src/chat/resolvers/ChatConvo.public.resolver.ts

@@ -0,0 +1,15 @@
+import {Resolver, Arg, Query} from 'type-graphql';
+import {ChatConvo} from '../models/ChatConvo.model';
+import {startPublicConvo} from '../methods/ChatConvoResolver.methods';
+
+@Resolver()
+export class ChatConvoPublicResolver {
+    @Query(() => ChatConvo)
+    async chatConvoPublicById(
+        @Arg('id', () => String, {nullable: false}) id: string
+    ): Promise<ChatConvo> {
+        return startPublicConvo(id);
+    }
+}
+
+export default ChatConvoPublicResolver;

package/src/chat/resolvers/ChatConvo.resolver.ts

@@ -0,0 +1,71 @@
+import {Resolver, Mutation, Ctx, Arg, Query, Subscription, Root, UseMiddleware} from 'type-graphql';
+import {ChatConvo, ChatConvoType} from '../models/ChatConvo.model';
+import {
+    chatConvo,
+    chatConvoById,
+    createChatConvo,
+    startConvo,
+} from '../methods/ChatConvoResolver.methods';
+import {isAuth} from '@roadmanjs/auth';
+import {ChatResType, getPagination, ContextType} from '../../shared/ContextType';
+import {OnChatMessage} from '../models';
+import _get from 'lodash/get';
+
+const ConvoPagination = getPagination(ChatConvo);
+
+@Resolver()
+export class ChatConvoResolver {
+    // TODO auth middleware
+    @Subscription(() => OnChatMessage, {
+        topics: ChatConvo.name,
+        filter: ({payload, args}) => args.owner === payload.owner,
+    })
+    onConvos(
+        @Root() data: OnChatMessage,
+        @Arg('owner', () => String, {nullable: false}) owner: string,
+        @Arg('time', () => Date, {nullable: true}) time: Date // just to make the client HOT
+    ): OnChatMessage {
+        return {time, owner, ...data};
+    }
+
+    @Query(() => ChatConvo)
+    @UseMiddleware(isAuth)
+    async chatConvoById(
+        @Ctx() ctx: ContextType,
+        @Arg('id', () => String, {nullable: false}) id: string
+    ): Promise<ChatConvo> {
+        const owner = _get(ctx, 'payload.userId', ''); // loggedIn user
+
+        return chatConvoById(id, owner);
+    }
+
+    @Query(() => ConvoPagination)
+    @UseMiddleware(isAuth)
+    async chatConvo(
+        @Arg('owner', () => String, {nullable: false}) owner: string,
+        // @Arg('sort', () => String, {nullable: true}) sortArg?: string,
+        @Arg('before', () => Date, {nullable: true}) before: Date,
+        @Arg('after', () => Date, {nullable: true}) after: Date,
+        @Arg('limit', () => Number, {nullable: true}) limit
+    ): Promise<{items: ChatConvo[]; hasNext: boolean; params: any}> {
+        return chatConvo({owner, before, after, limit});
+    }
+
+    @Mutation(() => ChatResType)
+    @UseMiddleware(isAuth)
+    async createChatConvo(
+        @Arg('args', () => ChatConvoType, {nullable: true}) args: ChatConvoType
+    ): Promise<ChatResType> {
+        return createChatConvo(args);
+    }
+
+    @Mutation(() => ChatResType)
+    @UseMiddleware(isAuth)
+    async startConvo(
+        @Arg('args', () => ChatConvoType, {nullable: true}) args: ChatConvoType
+    ): Promise<ChatResType> {
+        return startConvo(args);
+    }
+}
+
+export default ChatConvoResolver;

package/src/chat/resolvers/ChatMessage.resolver.ts

@@ -0,0 +1,62 @@
+import {Resolver, Query, Mutation, Arg, UseMiddleware, Ctx, Subscription, Root} from 'couchset';
+import {ContextType, ChatResType, getPagination} from '../../shared/ContextType';
+import {isAuth} from '@roadmanjs/auth';
+import {ChatMessage, ChatMessageType, OnChatMessage} from '../models/ChatMessage.model';
+import {chatTyping, chatMessage, createChatMessage} from '../methods/ChatMessageResolver.methods';
+
+const ChatPagination = getPagination(ChatMessage);
+
+@Resolver()
+export class ChatMessageResolver {
+    // TODO subscriptions and auth middleware
+    @Subscription(() => OnChatMessage, {
+        topics: ChatMessage.name,
+        filter: ({payload, args}) =>
+            args.convoId === payload.convoId && args.owner !== payload.owner,
+    })
+    onChatMessage(
+        @Root() data: OnChatMessage,
+        @Arg('owner', () => String, {nullable: true}) owner: string,
+        @Arg('convoId', () => String, {nullable: false}) convoId: string,
+        @Arg('time', () => Date, {nullable: true}) time: Date
+    ): OnChatMessage {
+        return {convoId, time, owner, ...data};
+    }
+
+    @Query(() => Boolean)
+    @UseMiddleware(isAuth)
+    async chatTyping(
+        @Ctx() ctx: ContextType,
+        @Arg('convoId', () => String, {nullable: false}) convoId: string,
+        @Arg('time', () => Date, {nullable: true}) time: Date // just to make the client HOT
+    ): Promise<boolean> {
+        return chatTyping(ctx, convoId, time);
+    }
+
+    @Query(() => ChatPagination)
+    async chatMessage(
+        @Ctx() ctx: ContextType,
+        @Arg('convoId', () => String, {nullable: false}) convoId: string,
+        //  @Arg('sort', () => String, {nullable: true}) sortArg?: string,
+        @Arg('before', () => Date, {nullable: true}) before: Date,
+        @Arg('after', () => Date, {nullable: true}) after: Date,
+        @Arg('limit', () => Number, {nullable: true}) limit
+    ): Promise<{
+        items: ChatMessage[];
+        hasNext: boolean;
+        params: any;
+    }> {
+        return chatMessage({ctx, convoId, before, after, limit});
+    }
+
+    @Mutation(() => ChatResType)
+    @UseMiddleware(isAuth)
+    async createChatMessage(
+        @Ctx() ctx: ContextType,
+        @Arg('args', () => ChatMessageType, {nullable: false}) args: ChatMessageType
+    ): Promise<ChatResType> {
+        return createChatMessage(ctx, args);
+    }
+}
+
+export default ChatMessageResolver;

package/src/chat/resolvers/index.ts

@@ -0,0 +1,2 @@
+export * from './ChatConvo.resolver';
+export * from './ChatMessage.resolver';

package/src/chat/subscriptions/README.md

@@ -0,0 +1 @@
+# Only for client query graphql-tags

package/src/chat/subscriptions/chatConvo.subscription.ts

@@ -0,0 +1,19 @@
+import gql from 'graphql-tag';
+
+export const ON_CHAT_CONVO_SUBSCRIPTION = gql`
+    subscription onChatConvo($convoId: String!) {
+        data: onChatConvo(convoId: $convoId)
+    }
+`;
+
+export const ON_CONVOS_SUBSCRIPTION = gql`
+    subscription OnConvos($owner: String!, $time: DateTime) {
+        data: onConvos(owner: $owner, time: $time) {
+            convoId
+            typing
+            message
+            time
+            owner
+        }
+    }
+`;

package/src/chat/subscriptions/chatMessage.subscription.ts

@@ -0,0 +1,13 @@
+import gql from 'graphql-tag';
+
+export const ON_CHAT_MESSAGE_SUBSCRIPTION = gql`
+    subscription OnChatMessage($owner: String, $convoId: String!, $time: DateTime) {
+        data: onChatMessage(owner: $owner, convoId: $convoId, time: $time) {
+            convoId
+            typing
+            message
+            time
+            owner
+        }
+    }
+`;

package/src/chat/subscriptions/index.ts

@@ -0,0 +1,2 @@
+export * from './chatConvo.subscription';
+export * from './chatMessage.subscription';

package/src/example.ts

@@ -0,0 +1,16 @@
+import 'reflect-metadata';
+
+import {couchsetRoadman} from '@roadmanjs/couchset';
+import {getChatResolvers} from '.';
+import {roadman} from 'roadman';
+
+roadman({
+    resolvers: [...getChatResolvers()],
+    roadmen: [couchsetRoadman as any],
+})
+    .then(() => {
+        console.log('roadman started');
+    })
+    .catch((error) => {
+        console.error(error);
+    });

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './chat';
+export * from './roadman';

package/src/roadman.ts

@@ -0,0 +1,25 @@
+import 'reflect-metadata';
+import 'dotenv/config';
+
+import {ChatConvoResolver, ChatMessageResolver} from './chat/resolvers';
+import {RoadMan, RoadmanBuild} from '@roadmanjs/core';
+
+// import {configureFirebase} from '@roadmanjs/firebase-admin';
+import ChatConvoPublicResolver from './chat/resolvers/ChatConvo.public.resolver';
+
+/**
+ * A roadman for chat and groups, using UserType from 'auth'
+ * @param RoadmanBuild
+ */
+export const chatRoadman: RoadMan = async (args: RoadmanBuild): Promise<RoadmanBuild> => {
+    // await configureFirebase();
+    return args;
+};
+
+export const getChatResolvers = () => [
+    ChatConvoResolver,
+    ChatMessageResolver,
+    ChatConvoPublicResolver,
+];
+
+export default chatRoadman;

package/src/scripts/copyClient.ts

@@ -0,0 +1,64 @@
+import {createClientPackageJson} from './createPackageJsonForClient';
+import shelljs from 'shelljs';
+import {writeFileSync} from 'fs';
+/**
+ * TODO script to copy fragments, query, mutations, subscriptions into client output
+ * - The copy some parts of package-json, like version number
+ * - Publish the separate client package.
+ */
+
+/**
+ Using shell we create an output folder with these files
+ dist-client
+   - README.md
+   - package.json (edited with minimal deps)
+   - docs
+   - register
+   - dist              ✅
+        - fragments
+        - query
+        - mutations
+        - subscriptions
+     - index.ts
+
+@PS - NOTES to friends reading this.
+ - Why not use yarn workspaces? these are smaller packages, some might have very few files, plus lerna private e.t.c...
+ - A script is more efficient and faster, can run together with main publishing CI/CD
+ - Two bird with one stone.
+
+ */
+
+(async () => {
+    // Dirs
+    shelljs.rm('-rf', 'dist-client');
+    shelljs.mkdir('-p', 'dist-client');
+    shelljs.mkdir('-p', 'dist-client/dist');
+
+    // register & docs
+    shelljs.cp('-rf', 'register', 'dist-client/register');
+    shelljs.cp('-rf', 'docs', 'dist-client/docs');
+
+    // README.md
+    shelljs.cp('-rf', 'README.md', 'dist-client/README.md');
+
+    // package.json
+    // TODO edit package.json to make it smaller with less deps
+    // shelljs.cp('-rf', 'package.json', 'dist-client/package.json');
+
+    // frags, query, mutations, sub
+    shelljs.cp('-rf', 'dist/chat/fragments', 'dist-client/dist/fragments');
+    shelljs.cp('-rf', 'dist/chat/query', 'dist-client/dist/query');
+    shelljs.cp('-rf', 'dist/chat/mutations', 'dist-client/dist/mutations');
+    shelljs.cp('-rf', 'dist/chat/subscriptions', 'dist-client/dist/subscriptions');
+
+    // index
+    shelljs.cp('-rf', 'dist/chat/index-client.d.ts', 'dist-client/dist/index.d.ts');
+    shelljs.cp('-rf', 'dist/chat/index-client.js', 'dist-client/dist/index.js');
+    shelljs.cp('-rf', 'dist/chat/index-client.js.map', 'dist-client/dist/index.js.map');
+
+    const getPackageJsonFile = await createClientPackageJson();
+    console.log('string file', JSON.stringify(getPackageJsonFile));
+    writeFileSync('dist-client/package.json', JSON.stringify(getPackageJsonFile), {
+        encoding: 'utf8',
+    });
+})();

package/src/scripts/createPackageJsonForClient.ts

@@ -0,0 +1,32 @@
+/**
+ * A simple script to copy current version from main package.json and create a client version
+ */
+
+import {readFileSync} from 'fs';
+
+/**
+ * Re-usable method for generating client package.json
+ * @param clientPackageName
+ */
+export const createClientPackageJson = async (): Promise<Object> => {
+    const packageFile: any = await readFileSync('package.json', {encoding: 'utf8'});
+    const packageContentJSON = JSON.parse(packageFile);
+
+    const newPackage: Object = {
+        ...packageContentJSON,
+        name: '@roadmanjs/chat-client', // TODO edit it from props
+        description: '@roadmanjs/chat fragments, query, mutations, subscriptions', // TODO from args
+        dependencies: {
+            // make it only one dep for easy client react .e.t.c
+            'graphql-tag': '^2.12.5',
+        },
+        devDependencies: {}, // make it empty
+        peerDependencies: {}, // make it empty
+        scripts: {}, // empty scripts
+    };
+
+    // console.log('new packageJson file', newPackage);
+
+    return newPackage;
+};
+createClientPackageJson();

package/src/shared/ContextType.ts

@@ -0,0 +1,67 @@
+import {Field, ObjectType} from 'couchset';
+// import { GraphQLObjectType, GraphQLScalarType } from "graphql"
+import {Request, Response} from 'express';
+
+import GraphQLJSON from 'graphql-type-json';
+import {RedisPubSub} from 'graphql-redis-subscriptions';
+
+export {GeoType} from 'couchset';
+
+export interface ContextType {
+    req: Request;
+    res: Response;
+    payload?: any;
+    pubsub: RedisPubSub;
+}
+
+/**
+ * GraphQL Types start
+ */
+
+/**
+ * ChatResType
+ */
+
+export interface GeoLocationType {
+    lat: number;
+    lon: number;
+}
+
+// export const getPagination = <T>(c: T): any =>
+//     new GraphQLObjectType({
+//         name: `${(c as any).name}Pagination`,
+//         fields: () => ({
+//             // items: {type: new GraphQLList(c as any)},
+//             hasNext: {type: GraphQLBoolean},
+//             params: {type: GraphQLString}, // TODO to GraphQLJSON
+//         }),
+//     });
+
+@ObjectType()
+export class ChatResType {
+    @Field(() => Boolean)
+    success: boolean;
+
+    @Field(() => String, {nullable: true})
+    message?: string;
+
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    @Field((type) => GraphQLJSON, {nullable: true})
+    data?: any;
+}
+
+export const getPagination = <T>(c: T): any => {
+    @ObjectType(`${(c as any).name}Pagination`)
+    class Pagination {
+        @Field(() => [c], {nullable: true})
+        items: [typeof c];
+
+        @Field(() => Boolean, {nullable: true})
+        hasNext?: boolean;
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        @Field((type) => GraphQLJSON, {nullable: true})
+        params?: any;
+    }
+    return Pagination;
+};