import { Entities } from '@fasstech/oip-core';
import { getCompanyName, getCompanySiren, getCompanySiret } from '@fasstech/oip-core/entities/Company';
import * as R from 'ramda';

export const getCompany = async (_, context) => {
  const { projectId } = context.process;
  const project = await Entities('Project').get({ id: projectId });
  const company = await Entities('Company').get(project, { filter: R.propEq('oip-starter', 'externalId') });

  return company == null
    ? { name: '', siren: '', siret: '' }
    : { name: getCompanyName(company), siren: getCompanySiren(company), siret: getCompanySiret(company) };
};

export default getCompany;

import { Entities } from '@fasstech/oip-core';
import * as R from 'ramda';
import { describe, expect, it, vi } from 'vitest';
import { getCompany } from './getCompany.mjs';

vi.mock('@fasstech/oip-core', () => ({
  Entities: vi.fn()
}));

vi.mock('@fasstech/oip-core/entities/Company', () => ({
  getCompanyName: R.prop('name'),
  getCompanySiren: R.prop('siren'),
  getCompanySiret: R.prop('siret')
}));

describe('getCompany', () => {
  it('returns company data when company exists', async () => {
    const project = { id: '1234' };
    const company = {
      externalId: 'oip-starter',
      name: 'My Company',
      siren: '123456789',
      siret: '987654321'
    };

    Entities.mockReturnValue({
      get: vi.fn().mockResolvedValueOnce(project).mockResolvedValueOnce(company)
    });

    const res = await getCompany(null, { process: { projectId: project.id } });

    expect(res).toStrictEqual(R.pick(['name', 'siren', 'siret'], company));

    expect(Entities().get).toHaveBeenCalledTimes(2);
    expect(Entities().get).toHaveBeenNthCalledWith(1, { id: project.id });
    expect(Entities().get).toHaveBeenNthCalledWith(2, project, { filter: expect.any(Function) });
  });

  it('returns default values when company does not exist', async () => {
    const project = { id: '1234' };

    Entities.mockReturnValue({
      get: vi.fn().mockResolvedValueOnce(project).mockResolvedValueOnce(null)
    });

    const res = await getCompany(null, { process: { projectId: project.id } });

    expect(res).toStrictEqual({ name: '', siren: '', siret: '' });

    expect(Entities().get).toHaveBeenCalledTimes(2);
    expect(Entities().get).toHaveBeenNthCalledWith(1, { id: project.id });
    expect(Entities().get).toHaveBeenNthCalledWith(2, project, { filter: expect.any(Function) });
  });
});

import { Entities } from '@fasstech/oip-core';
import {
  setCompanyExternalId,
  setCompanyName,
  setCompanySiren,
  setCompanySiret
} from '@fasstech/oip-core/entities/Company';
import * as R from 'ramda';

export const createCompany = async (args, context) => {
  const { projectId } = context.process;
  const { name, siren, siret } = args;

  try {
    let project = await Entities('Project').get({ id: projectId });

    let company = await Entities('Company').getOrCreate(project, { filter: R.propEq('oip-starter', 'externalId') });

    company = R.pipe(
      setCompanyExternalId('oip-starter'),
      setCompanyName(name),
      setCompanySiren(siren),
      setCompanySiret(siret)
    )(company);

    project = await Entities('Company').save(project, company);
    await Entities('Project').save(project);

    return { ok: true, error: null };
  } catch (err) {
    return { ok: false, error: err.message };
  }
};

export default createCompany;

import { Entities } from '@fasstech/oip-core';
import {
  setCompanyExternalId,
  setCompanyName,
  setCompanySiren,
  setCompanySiret
} from '@fasstech/oip-core/entities/Company';
import * as R from 'ramda';
import { describe, expect, it, vi } from 'vitest';
import { createCompany } from './createCompany.mjs';

vi.mock('@fasstech/oip-core', () => ({
  Entities: vi.fn()
}));

vi.mock('@fasstech/oip-core/entities/Company', () => ({
  setCompanyExternalId: vi.fn(),
  setCompanyName: vi.fn(),
  setCompanySiren: vi.fn(),
  setCompanySiret: vi.fn()
}));

describe('createCompany', () => {
  it('creates a new company and attaches it to project entity', async () => {
    const project = { id: '1234' };
    const company = {
      externalId: 'oip-starter',
      name: 'My Company',
      siren: '123456789',
      siret: '987654321'
    };

    Entities.mockReturnValue({
      get: vi.fn().mockResolvedValue({ id: '1234' }),
      getOrCreate: vi.fn().mockResolvedValue({}),
      save: vi
        .fn()
        .mockResolvedValueOnce({ ...project, company })
        .mockResolvedValueOnce({ ...project, company })
    });

    setCompanyExternalId.mockImplementation(R.assoc('externalId'));
    setCompanyName.mockImplementation(R.assoc('name'));
    setCompanySiren.mockImplementation(R.assoc('siren'));
    setCompanySiret.mockImplementation(R.assoc('siret'));

    const res = await createCompany(R.pick(['name', 'siren', 'siret'], company), {
      process: { projectId: project.id }
    });

    expect(res).toStrictEqual({ ok: true, error: null });

    expect(setCompanyExternalId).toHaveBeenCalledWith(company.externalId);
    expect(setCompanyName).toHaveBeenCalledWith(company.name);
    expect(setCompanySiren).toHaveBeenCalledWith(company.siren);
    expect(setCompanySiret).toHaveBeenCalledWith(company.siret);

    expect(Entities().get).toHaveBeenCalledWith({ id: project.id });
    expect(Entities().getOrCreate).toHaveBeenCalledWith({ id: project.id }, { filter: expect.any(Function) });
    expect(Entities().save).toHaveBeenCalledTimes(2);
    expect(Entities().save).toHaveBeenNthCalledWith(1, project, company);
    expect(Entities().save).toHaveBeenNthCalledWith(2, { ...project, company });
  });

  it('handles error', async () => {
    Entities.mockReturnValue({
      get: vi.fn().mockImplementation(() => {
        throw new Error('error');
      })
    });

    const res = await createCompany(
      { name: 'My Company', siren: '123456789', siret: '987654321' },
      { process: { projectId: '1234' } }
    );

    expect(res).toStrictEqual({ ok: false, error: 'error' });
  });
});