shift-swap 0.1.0

package/dist/index.js

@@ -0,0 +1,698 @@
+// src/shared/result.ts
+class Result {
+  isSuccess;
+  isFailure;
+  error;
+  _value;
+  constructor(isSuccess, error, value) {
+    if (isSuccess && error) {
+      throw new Error("InvalidOperation: A result cannot be successful and contain an error");
+    }
+    if (!isSuccess && !error) {
+      throw new Error("InvalidOperation: A failing result needs to contain an error message");
+    }
+    this.isSuccess = isSuccess;
+    this.isFailure = !isSuccess;
+    this.error = error;
+    this._value = value;
+    Object.freeze(this);
+  }
+  getValue() {
+    if (this.isFailure) {
+      throw new Error(`Cannot get the value of a failed result. Use 'error' instead. Error: ${this.formatError()}`);
+    }
+    return this._value;
+  }
+  static ok(value) {
+    return new Result(true, undefined, value);
+  }
+  static fail(error) {
+    return new Result(false, error);
+  }
+  static combine(results) {
+    for (const result of results) {
+      if (result.isFailure)
+        return result;
+    }
+    return Result.ok();
+  }
+  formatError() {
+    return this.error instanceof Error ? this.error.message : String(this.error);
+  }
+}
+// src/shared/entity.ts
+class Entity {
+  _id;
+  props;
+  constructor(props, id) {
+    this._id = id ?? crypto.randomUUID();
+    this.props = props;
+  }
+  get id() {
+    return this._id;
+  }
+  equals(other) {
+    if (other == null)
+      return false;
+    if (this === other)
+      return true;
+    if (!(other instanceof Entity))
+      return false;
+    return this._id === other._id;
+  }
+  toString() {
+    return `${this.constructor.name}(${this._id})`;
+  }
+}
+
+// src/shared/value-object.ts
+class ValueObject {
+  value;
+  constructor(value) {
+    this.value = Object.freeze(value);
+  }
+  equals(other) {
+    if (other == null)
+      return false;
+    if (!(other instanceof ValueObject))
+      return false;
+    return ValueObject.isEqual(this.value, other.value);
+  }
+  isEmpty() {
+    if (this.value == null)
+      return true;
+    if (typeof this.value === "string")
+      return this.value.trim().length === 0;
+    if (typeof this.value === "number")
+      return Number.isNaN(this.value);
+    if (Array.isArray(this.value))
+      return this.value.length === 0;
+    return false;
+  }
+  toString() {
+    return typeof this.value === "object" && this.value !== null ? JSON.stringify(this.value) : String(this.value);
+  }
+  static isEqual(a, b) {
+    if (a === b)
+      return true;
+    if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+      return false;
+    }
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    return aKeys.every((key) => ValueObject.isEqual(a[key], b[key]));
+  }
+}
+
+// src/core/entities/email.vo.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+class EmailVO extends ValueObject {
+  constructor(value) {
+    super(value);
+  }
+  static create(email) {
+    if (!email || email.trim().length === 0) {
+      return Result.fail("Email não pode ser vazio");
+    }
+    if (!EMAIL_REGEX.test(email)) {
+      return Result.fail(`Email inválido: ${email}`);
+    }
+    return Result.ok(new EmailVO(email));
+  }
+}
+
+// src/core/entities/name.vo.ts
+var MIN_LENGTH = 3;
+
+class NameVO extends ValueObject {
+  constructor(value) {
+    super(value);
+  }
+  static create(name) {
+    if (!name || name.trim().length === 0) {
+      return Result.fail("Nome não pode ser vazio");
+    }
+    if (name.trim().length < MIN_LENGTH) {
+      return Result.fail(`Nome deve ter pelo menos ${MIN_LENGTH} caracteres`);
+    }
+    return Result.ok(new NameVO(name));
+  }
+}
+
+// src/core/entities/pessoa.entity.ts
+class PessoaEntity extends Entity {
+  constructor(props, id) {
+    super(props, id);
+  }
+  get name() {
+    return this.props.name;
+  }
+  get email() {
+    return this.props.email;
+  }
+  atualizarDados(props) {
+    const propsOrError = PessoaEntity.buildProps(props);
+    if (propsOrError.isFailure) {
+      return Result.fail(propsOrError.error);
+    }
+    this.props = propsOrError.getValue();
+    return Result.ok();
+  }
+  static buildProps(props) {
+    const nameOrError = NameVO.create(props.name);
+    const emailOrError = EmailVO.create(props.email);
+    const combined = Result.combine([nameOrError, emailOrError]);
+    if (combined.isFailure) {
+      return Result.fail(combined.error);
+    }
+    return Result.ok({ name: nameOrError.getValue(), email: emailOrError.getValue() });
+  }
+  static create(props, id) {
+    const propsOrError = PessoaEntity.buildProps(props);
+    if (propsOrError.isFailure) {
+      return Result.fail(propsOrError.error);
+    }
+    return Result.ok(new PessoaEntity(propsOrError.getValue(), id));
+  }
+}
+
+// src/core/entities/funcionario.entity.ts
+class FuncionarioEntity extends PessoaEntity {
+  constructor(props, id) {
+    super(props, id);
+  }
+  static create(props, id) {
+    const propsOrError = FuncionarioEntity.buildProps(props);
+    if (propsOrError.isFailure) {
+      return Result.fail(propsOrError.error);
+    }
+    return Result.ok(new FuncionarioEntity(propsOrError.getValue(), id));
+  }
+}
+// src/core/entities/supervisor.entity.ts
+class SupervisorEntity extends PessoaEntity {
+  constructor(props, id) {
+    super(props, id);
+  }
+  static create(props, id) {
+    const propsOrError = SupervisorEntity.buildProps(props);
+    if (propsOrError.isFailure) {
+      return Result.fail(propsOrError.error);
+    }
+    return Result.ok(new SupervisorEntity(propsOrError.getValue(), id));
+  }
+}
+// src/core/entities/turno.entity.ts
+var DATA_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var HORA_REGEX = /^([01]\d|2[0-3]):[0-5]\d$/;
+
+class Turno extends Entity {
+  constructor(props, id) {
+    super(props, id);
+  }
+  get data() {
+    return this.props.data;
+  }
+  get horaInicio() {
+    return this.props.horaInicio;
+  }
+  get horaFim() {
+    return this.props.horaFim;
+  }
+  get funcionarioId() {
+    return this.props.funcionarioId;
+  }
+  reatribuir(novoFuncionarioId) {
+    if (!novoFuncionarioId || novoFuncionarioId.trim().length === 0) {
+      return Result.fail("Id do novo funcionário não pode ser vazio");
+    }
+    if (novoFuncionarioId === this.props.funcionarioId) {
+      return Result.fail("O turno já pertence a esse funcionário");
+    }
+    this.props.funcionarioId = novoFuncionarioId;
+    return Result.ok();
+  }
+  atualizarHorario(horario) {
+    const validacao = Turno.validarHorario(horario);
+    if (validacao.isFailure) {
+      return validacao;
+    }
+    this.props.data = horario.data;
+    this.props.horaInicio = horario.horaInicio;
+    this.props.horaFim = horario.horaFim;
+    return Result.ok();
+  }
+  static validarHorario(horario) {
+    if (!DATA_REGEX.test(horario.data)) {
+      return Result.fail(`Data inválida: ${horario.data}`);
+    }
+    if (!HORA_REGEX.test(horario.horaInicio)) {
+      return Result.fail(`Hora de início inválida: ${horario.horaInicio}`);
+    }
+    if (!HORA_REGEX.test(horario.horaFim)) {
+      return Result.fail(`Hora de fim inválida: ${horario.horaFim}`);
+    }
+    if (horario.horaFim <= horario.horaInicio) {
+      return Result.fail("Hora de fim deve ser depois da hora de início");
+    }
+    return Result.ok();
+  }
+  static create(props, id) {
+    const validacao = Turno.validarHorario(props);
+    if (validacao.isFailure) {
+      return Result.fail(validacao.error);
+    }
+    if (!props.funcionarioId || props.funcionarioId.trim().length === 0) {
+      return Result.fail("Id do funcionário não pode ser vazio");
+    }
+    return Result.ok(new Turno({
+      data: props.data,
+      horaInicio: props.horaInicio,
+      horaFim: props.horaFim,
+      funcionarioId: props.funcionarioId
+    }, id));
+  }
+}
+// src/core/entities/solicitacao-troca-turno.entity.ts
+class SolicitacaoTrocaTurno extends Entity {
+  constructor(props, id) {
+    super(props, id);
+  }
+  get turno() {
+    return this.props.turno;
+  }
+  get solicitanteId() {
+    return this.props.solicitanteId;
+  }
+  get destinatarioId() {
+    return this.props.destinatarioId;
+  }
+  get status() {
+    return this.props.status;
+  }
+  aceitar(funcionarioId) {
+    if (this.props.status !== "pendente") {
+      return Result.fail("Solicitação de troca não está mais pendente");
+    }
+    if (funcionarioId === this.props.solicitanteId) {
+      return Result.fail("O solicitante não pode aceitar a própria solicitação");
+    }
+    const reatribuidoOrError = this.props.turno.reatribuir(funcionarioId);
+    if (reatribuidoOrError.isFailure) {
+      return Result.fail(reatribuidoOrError.error);
+    }
+    this.props.destinatarioId = funcionarioId;
+    this.props.status = "aceita";
+    return Result.ok();
+  }
+  cancelar() {
+    if (this.props.status !== "pendente") {
+      return Result.fail("Solicitação de troca não está mais pendente");
+    }
+    this.props.status = "cancelada";
+    return Result.ok();
+  }
+  static create(props, id) {
+    if (props.solicitanteId !== props.turno.funcionarioId) {
+      return Result.fail("Somente o funcionário dono do turno pode solicitar a troca");
+    }
+    return Result.ok(new SolicitacaoTrocaTurno({ turno: props.turno, solicitanteId: props.solicitanteId, status: "pendente" }, id));
+  }
+}
+// src/shared/repository.ts
+class Repository {
+}
+
+// src/core/ports/funcionario.repository.ts
+class FuncionarioRepository extends Repository {
+}
+// src/core/ports/supervisor.repository.ts
+class SupervisorRepository extends Repository {
+}
+// src/core/ports/turno.repository.ts
+class TurnoRepository extends Repository {
+}
+// src/core/ports/solicitacao-troca-turno.repository.ts
+class SolicitacaoTrocaTurnoRepository extends Repository {
+}
+// src/shared/use-case.ts
+class UseCase {
+}
+
+// src/core/usecases/criar-funcionario.usecase.ts
+class CriarFuncionarioUseCase extends UseCase {
+  funcionarioRepository;
+  constructor(funcionarioRepository) {
+    super();
+    this.funcionarioRepository = funcionarioRepository;
+  }
+  async execute(input) {
+    const funcionarioOrError = FuncionarioEntity.create(input, input.id);
+    if (funcionarioOrError.isFailure) {
+      return Result.fail(funcionarioOrError.error);
+    }
+    const funcionario = funcionarioOrError.getValue();
+    await this.funcionarioRepository.save(funcionario);
+    return Result.ok(funcionario);
+  }
+}
+// src/core/usecases/buscar-funcionario-por-id.usecase.ts
+class BuscarFuncionarioPorIdUseCase extends UseCase {
+  funcionarioRepository;
+  constructor(funcionarioRepository) {
+    super();
+    this.funcionarioRepository = funcionarioRepository;
+  }
+  async execute(input) {
+    const funcionario = await this.funcionarioRepository.findById(input.id);
+    if (!funcionario) {
+      return Result.fail("Funcionário não encontrado");
+    }
+    return Result.ok(funcionario);
+  }
+}
+// src/core/usecases/listar-funcionarios.usecase.ts
+class ListarFuncionariosUseCase extends UseCase {
+  funcionarioRepository;
+  constructor(funcionarioRepository) {
+    super();
+    this.funcionarioRepository = funcionarioRepository;
+  }
+  async execute() {
+    const funcionarios = await this.funcionarioRepository.findAll();
+    return Result.ok(funcionarios);
+  }
+}
+// src/core/usecases/atualizar-funcionario.usecase.ts
+class AtualizarFuncionarioUseCase extends UseCase {
+  funcionarioRepository;
+  constructor(funcionarioRepository) {
+    super();
+    this.funcionarioRepository = funcionarioRepository;
+  }
+  async execute(input) {
+    const funcionario = await this.funcionarioRepository.findById(input.id);
+    if (!funcionario) {
+      return Result.fail("Funcionário não encontrado");
+    }
+    const atualizarOrError = funcionario.atualizarDados({ name: input.name, email: input.email });
+    if (atualizarOrError.isFailure) {
+      return Result.fail(atualizarOrError.error);
+    }
+    await this.funcionarioRepository.update(funcionario);
+    return Result.ok(funcionario);
+  }
+}
+// src/core/usecases/remover-funcionario.usecase.ts
+class RemoverFuncionarioUseCase extends UseCase {
+  funcionarioRepository;
+  constructor(funcionarioRepository) {
+    super();
+    this.funcionarioRepository = funcionarioRepository;
+  }
+  async execute(input) {
+    const funcionario = await this.funcionarioRepository.findById(input.id);
+    if (!funcionario) {
+      return Result.fail("Funcionário não encontrado");
+    }
+    await this.funcionarioRepository.delete(input.id);
+    return Result.ok();
+  }
+}
+// src/core/usecases/criar-supervisor.usecase.ts
+class CriarSupervisorUseCase extends UseCase {
+  supervisorRepository;
+  constructor(supervisorRepository) {
+    super();
+    this.supervisorRepository = supervisorRepository;
+  }
+  async execute(input) {
+    const supervisorOrError = SupervisorEntity.create(input, input.id);
+    if (supervisorOrError.isFailure) {
+      return Result.fail(supervisorOrError.error);
+    }
+    const supervisor = supervisorOrError.getValue();
+    await this.supervisorRepository.save(supervisor);
+    return Result.ok(supervisor);
+  }
+}
+// src/core/usecases/criar-turno.usecase.ts
+class CriarTurnoUseCase extends UseCase {
+  turnoRepository;
+  constructor(turnoRepository) {
+    super();
+    this.turnoRepository = turnoRepository;
+  }
+  async execute(input) {
+    const turnoOrError = Turno.create(input);
+    if (turnoOrError.isFailure) {
+      return Result.fail(turnoOrError.error);
+    }
+    const turno = turnoOrError.getValue();
+    await this.turnoRepository.save(turno);
+    return Result.ok(turno);
+  }
+}
+// src/core/usecases/buscar-turno-por-id.usecase.ts
+class BuscarTurnoPorIdUseCase extends UseCase {
+  turnoRepository;
+  constructor(turnoRepository) {
+    super();
+    this.turnoRepository = turnoRepository;
+  }
+  async execute(input) {
+    const turno = await this.turnoRepository.findById(input.id);
+    if (!turno) {
+      return Result.fail("Turno não encontrado");
+    }
+    return Result.ok(turno);
+  }
+}
+// src/core/usecases/listar-turnos.usecase.ts
+class ListarTurnosUseCase extends UseCase {
+  turnoRepository;
+  constructor(turnoRepository) {
+    super();
+    this.turnoRepository = turnoRepository;
+  }
+  async execute() {
+    const turnos = await this.turnoRepository.findAll();
+    return Result.ok(turnos);
+  }
+}
+// src/core/usecases/atualizar-turno.usecase.ts
+class AtualizarTurnoUseCase extends UseCase {
+  turnoRepository;
+  constructor(turnoRepository) {
+    super();
+    this.turnoRepository = turnoRepository;
+  }
+  async execute(input) {
+    const turno = await this.turnoRepository.findById(input.id);
+    if (!turno) {
+      return Result.fail("Turno não encontrado");
+    }
+    const atualizarOrError = turno.atualizarHorario({
+      data: input.data,
+      horaInicio: input.horaInicio,
+      horaFim: input.horaFim
+    });
+    if (atualizarOrError.isFailure) {
+      return Result.fail(atualizarOrError.error);
+    }
+    await this.turnoRepository.update(turno);
+    return Result.ok(turno);
+  }
+}
+// src/core/usecases/remover-turno.usecase.ts
+class RemoverTurnoUseCase extends UseCase {
+  turnoRepository;
+  constructor(turnoRepository) {
+    super();
+    this.turnoRepository = turnoRepository;
+  }
+  async execute(input) {
+    const turno = await this.turnoRepository.findById(input.id);
+    if (!turno) {
+      return Result.fail("Turno não encontrado");
+    }
+    await this.turnoRepository.delete(input.id);
+    return Result.ok();
+  }
+}
+// src/core/usecases/listar-turnos-por-funcionario-e-data.usecase.ts
+class ListarTurnosPorFuncionarioEDataUseCase extends UseCase {
+  turnoRepository;
+  constructor(turnoRepository) {
+    super();
+    this.turnoRepository = turnoRepository;
+  }
+  async execute(input) {
+    const turnos = await this.turnoRepository.findByFuncionarioIdAndData(input.funcionarioId, input.data);
+    return Result.ok(turnos);
+  }
+}
+// src/core/usecases/solicitar-troca-turno.usecase.ts
+class SolicitarTrocaTurnoUseCase extends UseCase {
+  turnoRepository;
+  solicitacaoRepository;
+  constructor(turnoRepository, solicitacaoRepository) {
+    super();
+    this.turnoRepository = turnoRepository;
+    this.solicitacaoRepository = solicitacaoRepository;
+  }
+  async execute(input) {
+    const turno = await this.turnoRepository.findById(input.turnoId);
+    if (!turno) {
+      return Result.fail("Turno não encontrado");
+    }
+    const pendentes = await this.solicitacaoRepository.findPendentesByTurnoId(turno.id);
+    if (pendentes.length > 0) {
+      return Result.fail("Já existe uma solicitação pendente para esse turno");
+    }
+    const solicitacaoOrError = SolicitacaoTrocaTurno.create({
+      turno,
+      solicitanteId: input.solicitanteId
+    });
+    if (solicitacaoOrError.isFailure) {
+      return Result.fail(solicitacaoOrError.error);
+    }
+    const solicitacao = solicitacaoOrError.getValue();
+    await this.solicitacaoRepository.save(solicitacao);
+    return Result.ok(solicitacao);
+  }
+}
+// src/core/usecases/aceitar-troca-turno.usecase.ts
+function horariosSeSobrepoem(a, b) {
+  return a.horaInicio < b.horaFim && b.horaInicio < a.horaFim;
+}
+
+class AceitarTrocaTurnoUseCase extends UseCase {
+  funcionarioRepository;
+  turnoRepository;
+  solicitacaoRepository;
+  constructor(funcionarioRepository, turnoRepository, solicitacaoRepository) {
+    super();
+    this.funcionarioRepository = funcionarioRepository;
+    this.turnoRepository = turnoRepository;
+    this.solicitacaoRepository = solicitacaoRepository;
+  }
+  async execute(input) {
+    const solicitacao = await this.solicitacaoRepository.findById(input.solicitacaoId);
+    if (!solicitacao) {
+      return Result.fail("Solicitação não encontrada");
+    }
+    const funcionario = await this.funcionarioRepository.findById(input.funcionarioId);
+    if (!funcionario) {
+      return Result.fail("Funcionário não encontrado");
+    }
+    const turnosDoFuncionario = await this.turnoRepository.findByFuncionarioIdAndData(input.funcionarioId, solicitacao.turno.data);
+    const temConflito = turnosDoFuncionario.some((turno) => horariosSeSobrepoem(turno, solicitacao.turno));
+    if (temConflito) {
+      return Result.fail("Funcionário já possui um turno nesse horário");
+    }
+    const aceitarOrError = solicitacao.aceitar(input.funcionarioId);
+    if (aceitarOrError.isFailure) {
+      return Result.fail(aceitarOrError.error);
+    }
+    await this.turnoRepository.update(solicitacao.turno);
+    await this.solicitacaoRepository.update(solicitacao);
+    return Result.ok(solicitacao);
+  }
+}
+// src/core/usecases/cancelar-troca-turno.usecase.ts
+class CancelarTrocaTurnoUseCase extends UseCase {
+  solicitacaoRepository;
+  constructor(solicitacaoRepository) {
+    super();
+    this.solicitacaoRepository = solicitacaoRepository;
+  }
+  async execute(input) {
+    const solicitacao = await this.solicitacaoRepository.findById(input.solicitacaoId);
+    if (!solicitacao) {
+      return Result.fail("Solicitação não encontrada");
+    }
+    if (solicitacao.solicitanteId !== input.solicitanteId) {
+      return Result.fail("Somente o solicitante pode cancelar a solicitação");
+    }
+    const cancelarOrError = solicitacao.cancelar();
+    if (cancelarOrError.isFailure) {
+      return Result.fail(cancelarOrError.error);
+    }
+    await this.solicitacaoRepository.update(solicitacao);
+    return Result.ok(solicitacao);
+  }
+}
+// src/core/usecases/buscar-solicitacao-troca-turno-por-id.usecase.ts
+class BuscarSolicitacaoTrocaTurnoPorIdUseCase extends UseCase {
+  solicitacaoRepository;
+  constructor(solicitacaoRepository) {
+    super();
+    this.solicitacaoRepository = solicitacaoRepository;
+  }
+  async execute(input) {
+    const solicitacao = await this.solicitacaoRepository.findById(input.id);
+    if (!solicitacao) {
+      return Result.fail("Solicitação não encontrada");
+    }
+    return Result.ok(solicitacao);
+  }
+}
+// src/core/usecases/listar-solicitacoes-troca-turno.usecase.ts
+class ListarSolicitacoesTrocaTurnoUseCase extends UseCase {
+  solicitacaoRepository;
+  constructor(solicitacaoRepository) {
+    super();
+    this.solicitacaoRepository = solicitacaoRepository;
+  }
+  async execute() {
+    const solicitacoes = await this.solicitacaoRepository.findAll();
+    return Result.ok(solicitacoes);
+  }
+}
+// src/core/usecases/listar-turnos-disponiveis-para-troca.usecase.ts
+class ListarTurnosDisponiveisParaTrocaUseCase extends UseCase {
+  solicitacaoRepository;
+  constructor(solicitacaoRepository) {
+    super();
+    this.solicitacaoRepository = solicitacaoRepository;
+  }
+  async execute(input) {
+    const solicitacoes = await this.solicitacaoRepository.findPendentesExcetoSolicitante(input.funcionarioId);
+    return Result.ok(solicitacoes);
+  }
+}
+export {
+  AceitarTrocaTurnoUseCase,
+  AtualizarFuncionarioUseCase,
+  AtualizarTurnoUseCase,
+  BuscarFuncionarioPorIdUseCase,
+  BuscarSolicitacaoTrocaTurnoPorIdUseCase,
+  BuscarTurnoPorIdUseCase,
+  CancelarTrocaTurnoUseCase,
+  CriarFuncionarioUseCase,
+  CriarSupervisorUseCase,
+  CriarTurnoUseCase,
+  EmailVO,
+  FuncionarioEntity,
+  FuncionarioRepository,
+  ListarFuncionariosUseCase,
+  ListarSolicitacoesTrocaTurnoUseCase,
+  ListarTurnosDisponiveisParaTrocaUseCase,
+  ListarTurnosPorFuncionarioEDataUseCase,
+  ListarTurnosUseCase,
+  NameVO,
+  RemoverFuncionarioUseCase,
+  RemoverTurnoUseCase,
+  Result,
+  SolicitacaoTrocaTurno,
+  SolicitacaoTrocaTurnoRepository,
+  SolicitarTrocaTurnoUseCase,
+  SupervisorEntity,
+  SupervisorRepository,
+  Turno,
+  TurnoRepository
+};

package/dist/shared/either.d.ts

@@ -0,0 +1,16 @@
+declare class Left<L, R> {
+    readonly value: L;
+    constructor(value: L);
+    isLeft(): this is Left<L, R>;
+    isRight(): this is Right<L, R>;
+}
+declare class Right<L, R> {
+    readonly value: R;
+    constructor(value: R);
+    isLeft(): this is Left<L, R>;
+    isRight(): this is Right<L, R>;
+}
+type Either<L, R> = Left<L, R> | Right<L, R>;
+declare const left: <L, R>(value: L) => Either<L, R>;
+declare const right: <L, R>(value: R) => Either<L, R>;
+export { Either, Left, Right, left, right };