MyEntity: {
    schema: {
        customProp: { type: String }
    }
}

MyEntity: {
    properties: {
        customProp: { type: 'string' }
    }
}

MyEntity: {
    parents: ['project'],
    multiple: {
        name: 'myentities'
    }
}

Project: {
    relations: {
        MyEntity: ['multiple', 'myentities']
    }
}

import { transitionRouter as router } from '@fasstech/oip-core/process'; // V2
// est remplacé par
import router from '@fasstech/oip-core/routes'; // V3

import { runTaskCtrl as runTask } from '@fasstech/oip-core/controllers'; // V2
// est remplacé par
import { runTask } from '@fasstech/oip-core/task'; // V3

// V2
await Entities('Address').get('Customer');
// V3
await Entities('Address').getOrCreate('Customer');

// V2
await Entities('Adress').get('Customer', addressId)
// V3
await Entities('Adress').get(
  'Customer',
  { filter: ({ id }) => id === addressId }
);

// Entité Project
Entities('Project').get({ id: getProjectId(project) })
// Autres entités
Entities('Company').get(
  project,
  { filter: ({ id }) => id === getCompanyId(company) }
);

export default [
   {
      srcViewId: 'id_de_la_vue_courante',
      tgtViewId: 'id_de_la_vue_cible',
      action: 'next', // 'next' ou 'prev'
      conditionLabel: 'nom_de_la_condition', // par convention, le nommage suit le format `${srcViewId}_${action}${tgtViewId}`
      conditionOrder: 1 // ordre d'exécution de la condition
  }
]

export default {
  rootView: 'home',
  views: ['home', 'summary']
};

CLI_TIMEOUT=8
echo "[CLI] RUN BUILD VIEWS\n"
oip-tools views build --config ./viewsConfig --gql-client relay --extFileBackend mjs

echo "[SLEEP] $CLI_TIMEOUT seconds\n"
sleep $CLI_TIMEOUT

echo "[YARN] getSchema\n"
yarn getSchema

echo "[YARN] relay\n"
yarn relay

echo "[YARN] lint fix error\n"
yarn lint > /dev/null

import { gql } from 'apollo-server-express';

const ProcessType = {
  typeDefs: gql`
    type Process {
      projectId: ID
      viewId: ID
    }
  `
};

export default ProcessType;

import { prop } from 'ramda';
import { gql } from 'apollo-server-express';

const TaskType = {
  typeDefs: gql`
    scalar TaskMetadata

    type TaskState {
      status: String
      statusCode: Int
    }

    type TaskHistory {
      updatedAt: String
      status: String
      statusCode: Int
      metadata: TaskMetadata
      error: String
    }

    type Task {
      id: ID
      taskName: String
      projectId: ID
      metadata: TaskMetadata
      error: String
      state: TaskState
      history: [TaskHistory]
    }
  `,
  resolvers: {
    Task: {
      id: prop('_id')
    }
  }
};

export default TaskType;

import { ProcessResolver } from '../resolver/index.mjs';

import { gql } from 'apollo-server-express';

const QueryType = {
  typeDefs: gql`
    interface QueryResponse {
      ok: Boolean!
      error: String
    }

    type TaskQueryResponse implements QueryResponse {
      ok: Boolean!
      error: String
      task: Task
    }

    type Query {
      process: Process
      task(taskName: String!, linkedToProject: Boolean): TaskQueryResponse
    }
  `,
  resolvers: {
    Query: {
      process: (parent, _, context) => ProcessResolver(context).get(),
      task: (parent, { taskName, linkedToProject }, context) => ProcessResolver(context).getTask({ taskName, linkedToProject })
    }
  }
};

export default QueryType;

import { ProcessResolver } from '../resolver/index.mjs';

import { gql } from 'apollo-server-express';

const MutationType = {
  typeDefs: gql`
    scalar ActionContext

    enum Action {
      PREV
      NEXT
    }
      
    interface MutationResponse {
      ok: Boolean!
      error: String
    }
    
    type ActionMutationResponse implements MutationResponse {
        ok: Boolean!
        error: String
        process: Process!
    }

    type TaskMutationResponse implements MutationResponse {
      ok: Boolean!
      error: String
      taskName: String
    }

    type Mutation {
      action(action: Action!, context: ActionContext): ActionMutationResponse
      runTask(taskName: String!, linkedToProject: Boolean, metadata: TaskMetadata): TaskMutationResponse
      killCronTask(taskName: String!): TaskMutationResponse
    }
  `,
  resolvers: {
    Mutation: {
      action: (parent, { action, context }, ctx) => ProcessResolver(ctx).action({ action, context }),
      runTask: (parent, { taskName, linkedToProject, metadata }, context) => ProcessResolver(context).runTask({ taskName, linkedToProject, metadata }),
      killCronTask: (parent, { taskName }, context) => ProcessResolver(context).killCronTask({ taskName })
    }
  }
};

export default MutationType;

import { gql } from 'apollo-server-express';
import { withFilter } from 'graphql-subscriptions';
import { pubsub } from '../initGraphql.mjs';

const SubscriptionType = {
  typeDefs: gql`
    type Subscription {
      taskSubscription(taskName: String!, projectId: String): TaskStateSubPayload
    }
  `,
  resolvers: {
    Subscription: {
      taskSubscription: {
        subscribe: withFilter(() => pubsub.asyncIterator('TASK_STATE_UPDATE'), (payload, variables) => {
          if (variables.projectId) {
            return payload.taskSubscription.taskName === variables.taskName &&
              payload.taskSubscription.projectId === variables.projectId;
          }
          return payload.taskSubscription.taskName === variables.taskName;
        })
      }
    }
  }
};

export default SubscriptionType;

import { logger } from '@fasstech/logger';
import { KO, OK } from './helpers.mjs';

// import des controllers des transitions
import { next, prev } from '@fasstech/oip-core/process';

// import des controllers des tâches
import {
  getTask as getTaskCtrl,
  runTask as runTaskCtrl,
  killTask as killTaskCtrl
} from '@fasstech/oip-core/task';

const ProcessResolver = ({
  process,
  sessionId
}) => (() => {
  // récupération de l'id du projet actuel depuis le context graphQL
  const { projectId } = process;

  // get process
  const get = () => {
    logger.info(`[ProcessResolver][get] info: sessionId=${sessionId} projectId=${projectId}`);
    return process;
  };

  // get task
  const getTask = async ({ taskName, linkedToProject }) => {
    logger.info(`[ProcessResolver][getTask] info: ${taskName}`);
    try {
      const task = await getTaskCtrl({
        taskName,
        projectId: linkedToProject ? projectId : null
      });

      return OK({ task });
    } catch (err) {
      return KO(err.message);
    }
  };

  // action (trigger transition)
  const action = async ({ action, context }) => {
    logger.info(`[ProcessResolver][action] info: ${action}`);
    const actions = {
      'NEXT': () => next(projectId, context),
      'PREV': () => prev(projectId, context)
    };

    try {
      const newViewId = await actions[action]();
      return OK({
        process: {
          projectId,
          viewId: newViewId
        }
      });
    } catch (err) {
      return KO(err, { process });
    }
  };

  // run task
  const runTask = async ({ taskName, linkedToProject, metadata }) => {
    logger.info(`[ProcessResolver][runTask] info: ${taskName}`);
    try {
      // not wait for the complete execution of the task, it can take time
      runTaskCtrl({
        taskName,
        metadata,
        projectId: linkedToProject ? projectId : null
      });
      return OK({ taskName });
    } catch (err) {
      return KO(err.message);
    }
  };

  // kill task
  const killCronTask = async ({ taskName }) => {
    logger.info(`[ProcessResolver][killCronTask] info: ${taskName}`);
    try {
      await killTaskCtrl({ taskName });
      return OK({ taskName });
    } catch (err) {
      return KO(err.message);
    }
  };

  return {
    get,
    getTask,
    action,
    runTask,
    killCronTask
  };
})();

export default ProcessResolver;

import { graphql } from 'react-relay';

const QProcessQuery = graphql`
  query QProcessQuery {
    process {
      projectId
      viewId
    }
  }
`;

const QProcess = {
  query: QProcessQuery
};

export default QProcess;

import { graphql } from 'react-relay';

const TaskQuery = graphql`
  query TaskQuery($taskName: String!, $linkedToProject: Boolean) {
    task(taskName: $taskName, linkedToProject: $linkedToProject) {
      ok
      error
      task {
        id
        taskName
        projectId
        metadata
        error
        state {
          status
          statusCode
        }
        history {
          status
          statusCode
          updatedAt
          metadata
          error
        }
      }
    }
  }
`;

const Task = {
  query: TaskQuery
};

export default Task;

import {
  commitMutation,
  graphql
} from 'react-relay';

const mutation = graphql`
  mutation ActionMutation($action: Action!, $context: ActionContext) {
    action(action: $action, context: $context) {
      ok
      error
      process {
        projectId
        viewId
      }
    }
  }
`;

export default (environment, { action, context }, done) => {
  const variables = { action, context };

  commitMutation(
    environment,
    {
      mutation,
      variables,
      updater: (store) => { },
      optimisticUpdater: () => {
      },
      onCompleted: (response) => {
        const { ok, error, process } = response.action;
        done(ok, error, process);
      },
      onError: err => console.error(err)
    }
  );
};

import {
  commitMutation,
  graphql
} from 'react-relay';

const mutation = graphql`
  mutation RunTaskMutation($taskName: String!, $linkedToProject: Boolean, $metadata: TaskMetadata) {
    runTask(taskName: $taskName, linkedToProject: $linkedToProject, metadata: $metadata) {
      ok
      error
      taskName
    }
  }
`;

export default (environment, { taskName, linkedToProject, metadata }, done) => {
  const variables = {
    taskName,
    linkedToProject,
    metadata
  };

  commitMutation(
    environment,
    {
      mutation,
      variables,
      updater: (store) => { },
      optimisticUpdater: () => {
      },
      onCompleted: (response) => {
        const { ok, error, taskName } = response.runTask;
        done(ok, error, taskName);
      },
      onError: err => console.error(err)
    }
  );
};

import {
  commitMutation,
  graphql
} from 'react-relay';

const mutation = graphql`
  mutation KillCronTaskMutation($taskName: String!) {
    killCronTask(taskName: $taskName) {
      ok
      error
      taskName
    }
  }
`;

export default (environment, { taskName }, done) => {
  const variables = { taskName };

  commitMutation(
    environment,
    {
      mutation,
      variables,
      updater: (store) => {},
      optimisticUpdater: () => {},
      onCompleted: (response) => {
        const { ok, error, taskName } = response.killCronTask;
        done(ok, error, taskName);
      },
      onError: err => console.error(err)
    }
  );
};

import { ActionMutation, RunTaskMutation, KillCronTaskMutation } from '@@appMutations';
import { QProcess, Task } from '@@appQueries';
import Moment from 'moment';
import { isNil } from 'ramda';
import { useEffect, useRef, useState } from 'react';
import { fetchQuery, useRelayEnvironment } from 'react-relay';

Moment.locale('fr');

const Process = ({ children }) => {
  const environment = useRelayEnvironment();
  const [process, setProcess] = useState(null);
  const processConfigurationRef = useRef();

  const getProcess = async () => {
    const response = await fetchQuery(environment, QProcess.query).toPromise();
    return response.process;
  };

  const getTask = async ({ taskName, linkedToProject }) => {
    const response = await fetchQuery(environment, Task.query, {
      taskName,
      linkedToProject,
    }).toPromise();
    return response.task;
  };

  useEffect(() => {
    /* get process configuration */
    async function fetchConfig() {
      const response = await fetch('/process/configuration', {
        method: 'GET',
        headers: {
          Accept: 'application/json',
          'Content-Type': 'application/json',
        },
      });
      processConfigurationRef.current = await response.json();
      const process = await getProcess();
      setProcess(process);
    }
    fetchConfig();
  }, []);

  if (isNil(process)) return null;
  
  /**
   * Trigger a transition
   * @param {'NEXT'|'PREV'} action
   * @param {object} context - any transition context (optional)
   */
  const onAction = ({ action, context }) => {
    ActionMutation(environment, { action, context }, (ok, error, process) => {
      setProcess(process);
    });
  };

  /**
   * Trigger next transition
   * @param {object} context - any transition context (optional)
   */
  const onNext = ({ context } = {}) => {
    ActionMutation(environment, { action: 'NEXT', context }, (ok, error, process) => {
      setProcess(process);
    });
  };

  /**
   * Trigger prev transition
   * @param {object} context - any transition context (optional)
   */
  const onPrev = ({ context } = {}) => {
    ActionMutation(environment, { action: 'PREV', context }, (ok, error, process) => {
      setProcess(process);
    });
  };

  /**
   * Trigger task execution
   * @param {string} taskName - related task name
   * @param {boolean} linkedToProject - if the task is linked to current project or not (optional, true by default)
   * @param {object} metadata - any metadata (optional)
   */
  const onRunTask = ({ taskName, linkedToProject = true, metadata }) => {
    RunTaskMutation(environment, { linkedToProject, taskName, metadata }, (ok, error, taskName) => {
      if (ok && !error) {
        console.log(`[RUN TASK] ${taskName}`);
        return;
      }
      console.error(`[RUN TASK] ${taskName} error: ${error}`);
    });
  };

  /**
   * Kill a CRON task
   * @param {string} taskName - related task name
   */
  const onKillCronTask = ({ taskName }) => {
    KillCronTaskMutation(environment, { taskName }, (ok, error, taskName) => {
      if (ok && !error) {
        console.log(`[KILL TASK] ${taskName} killed`);
        return;
      }
      console.error(`[KILL TASK] ${taskName} error: ${error}`);
    });
  };

  /**
   * Get a task
   * @param {string} taskName - related task name
   * @param linkedToProject - if the task is linked to current project or not (optional, true by default)
   * @return {Promise<Task|null>}
   */
  const onGetTask = async ({ taskName, linkedToProject = true }) => {
    const { ok, error, task } = await getTask({
      taskName,
      linkedToProject,
    });

    return ok && !error ? task : null;
  };

  /**
   * Get task status
   * @param {string} taskName - related task name
   * @param linkedToProject - if the task is linked to current project or not (optional, true by default)
   * @return {Promise<string|null>}
   */
  const onGetTaskStatus = async ({ taskName, linkedToProject = true }) => {
    const task = await getTask({ taskName, linkedToProject });
    return task?.state.status;
  };

  /**
   * Get task status code
   * @param {string} taskName - related task name
   * @param linkedToProject - if the task is linked to current project or not (optional, true by default)
   * @return {Promise<number|null>}
   */
  const onGetTaskStatusCode = async ({ taskName, linkedToProject = true }) => {
    const task = await getTask({ taskName, linkedToProject });
    return task?.state.statusCode;
  };

  return children({
    context: process,
    processConfiguration: processConfigurationRef.current,
    processHandlers: {
      onAction,
      onNext,
      onPrev,
      onRunTask,
      onGetTask,
      onKillCronTask,
      onGetTaskStatus,
      onGetTaskStatusCode,
    },
  });
};

export default Process;

import React from 'react';
import PropTypes from 'prop-types';
import Moment from 'moment';

Moment.locale('fr');

const ProcessContext = React.createContext();

export default function withProcess (Component) {
  return function ProcessComponent (props) {
    return (
      <ProcessContext.Consumer>
        {({
          context,
          processConfiguration,
          processHandlers
        }) => <Component
          {...props}
          context={context}
          processConfiguration={processConfiguration}
          processHandlers={processHandlers}
        />}
      </ProcessContext.Consumer>
    );
  };
}

const ContextPropTypes = PropTypes.shape({
  viewId: PropTypes.string,
  projectId: PropTypes.string
});

const ProcessConfigurationPropTypes = PropTypes.arrayOf(
  PropTypes.shape({
    path: PropTypes.string,
    viewId: PropTypes.string
  })
);

const ProcessHandlersPropTypes = PropTypes.shape({
  onAction: PropTypes.func,
  onNext: PropTypes.func,
  onPrev: PropTypes.func,
  onRunTask: PropTypes.func,
  onGetTask: PropTypes.func,
  onKillCronTask: PropTypes.func,
  onGetTaskStatus: PropTypes.func,
  onGetTaskStatusCode: PropTypes.func
});

export {
  ContextPropTypes,
  ProcessConfigurationPropTypes,
  ProcessHandlersPropTypes,
  ProcessContext
};

import withProcess, { actionIds, viewIds } from '@@app/withProcess';

const Home = ({ context, processHandlers }) => {
  ...

  return (
    <div className='t-home'>
      <h2>{viewIds.HOME}</h2>
      ...

    </div>
  );
};

export default withProcess(Home);

import withProcess, { actionIds, viewIds } from '@@app/withProcess';

const Home = ({ context, processHandlers }) => {
  const $onClick = (actionId) => () => {
    processHandlers.onAction(viewIds.HOME, actionId);
  };

  return (
    <div className='t-home'>
      <h2>{viewIds.HOME}</h2>
      ...
      
      <button className='f-button' onClick={$onClick(actionIds.HOME_NEXT)}>
        NEXT
      </button>
    </div>
  );
};

export default withProcess(Home);

import withProcess from '@@app/withProcess';
import { useState } from 'react';

const Home = ({ context, processHandlers }) => {
  const [magicTask, setMagicTask] = useState({});
  const { projectId, viewId } = context;

  // RUN TASK
  const onRunTask = () => {
    processHandlers.onRunTask({
      taskName: 'magicTask',
      // si oui ou non la tâche à exécuter sera liée
      // au projet actuel ou pas
      // (paramètre optionnel, true par défaut)
      linkedToProject: true,
    });
  };

  // GET TASK INFO
  const onGetTask = () => {
    processHandlers
      .onGetTask({
        taskName: 'magicTask',
        // si oui ou non la tâche à récupérer est liée
        // au projet actuel ou pas
        // (paramètre optionnel, true par défaut)
        linkedToProject: true,
      })
      .then((task) => {
        setMagicTask(task || {});
      })
      .catch((err) => {
        console.error(err);
        setMagicTask({});
      });
  };

  return (
    <div className='t-home'>
      <h2>{viewId.toUpperCase()}</h2>

      <div>
        <p>Magic task:</p>
        <pre>{JSON.stringify(magicTask, null, 2)}</pre>
      </div>

      <div>
        <button className='f-button' onClick={onRunTask}>
          RUN TASK
        </button>
        <button className='f-button ml-2' onClick={onGetTask}>
          GET INFO
        </button>
      </div>
      
      ...
    
    </div>
  );
};

export default withProcess(Home);

import withProcess from '@@app/withProcess';

// import relatif à la souscription d'une tâche
import { TaskSubscription } from '@@views/_common/graphql/subscriptions/TaskSubscription';
import { useSubscription } from '@@viewCommonHooks/useSubscription';

const Demo = ({ context, processHandlers }) => {
  // init task subscription
  const { outputValue, errorValue } = useSubscription({
    taskName: 'magicTask',
    projectId: context.projectId
  }, TaskSubscription);

  // run task
  const $onRunTask = () => {
    processHandlers.onRunTask({ taskName: 'magicTask' });
  };

  return (
    <div className="t-demo">
      <h2>{context.viewId.toUpperCase()}</h2>
      ...
      
      <div>
        <pre>{JSON.stringify(outputValue || {}, null, 2)}</pre>
        <pre>{JSON.stringify(errorValue || {}, null, 2)}</pre>
        <button className="f-button" onClick={$onRunTask}>RUN TASK</button>
      </div>
    </div>
  );
};

export default withProcess(Demo);