@alexisapp/leave-core 0.0.1-beta.1

package/src/graphql/operations/hr-core/work-calendar/queries.graphql

@@ -0,0 +1,60 @@
+query ListCompanyHolidays(
+  $filters: CompanyHolidayFilterInput
+  $limit: Int
+  $skip: Int
+  $sort: CompanyHolidaySortInput
+) {
+  companyHolidays(filters: $filters, limit: $limit, skip: $skip, sort: $sort) {
+    rows {
+      id
+      name
+      startDate
+      endDate
+      created
+      updated
+    }
+    count
+    next
+  }
+}
+
+query ListPublicHolidays(
+  $filters: PublicHolidayFilterInput
+  $limit: Int
+  $skip: Int
+  $sort: PublicHolidaySortInput
+) {
+  publicHolidays(filters: $filters, limit: $limit, skip: $skip, sort: $sort) {
+    rows {
+      id
+      name
+      label
+      date
+      country
+      public
+      calendarId
+    }
+    count
+    next
+  }
+}
+
+query ListRestrictedDates(
+  $filters: RestrictedDateFilterInput
+  $limit: Int
+  $skip: Int
+  $sort: RestrictedDateSortInput
+) {
+  restrictedDates(filters: $filters, limit: $limit, skip: $skip, sort: $sort) {
+    rows {
+      id
+      name
+      startDate
+      endDate
+      created
+      updated
+    }
+    count
+    next
+  }
+}

package/src/graphql/operations/hr-core/work-week/queries.graphql

@@ -0,0 +1,139 @@
+query GetWorkWeek($id: ID!) {
+  workWeek(id: $id) {
+    id
+    companyId
+    employeeId
+    officeId
+    effectiveFrom
+    effectiveTo
+    duration
+    timezone
+    monday {
+      working
+      duration
+      shifts {
+        startHour
+        startMinute
+        endHour
+        endMinute
+        duration
+      }
+    }
+    tuesday {
+      working
+      duration
+      shifts {
+        startHour
+        startMinute
+        endHour
+        endMinute
+        duration
+      }
+    }
+    wednesday {
+      working
+      duration
+      shifts {
+        startHour
+        startMinute
+        endHour
+        endMinute
+        duration
+      }
+    }
+    thursday {
+      working
+      duration
+      shifts {
+        startHour
+        startMinute
+        endHour
+        endMinute
+        duration
+      }
+    }
+    friday {
+      working
+      duration
+      shifts {
+        startHour
+        startMinute
+        endHour
+        endMinute
+        duration
+      }
+    }
+    saturday {
+      working
+      duration
+      shifts {
+        startHour
+        startMinute
+        endHour
+        endMinute
+        duration
+      }
+    }
+    sunday {
+      working
+      duration
+      shifts {
+        startHour
+        startMinute
+        endHour
+        endMinute
+        duration
+      }
+    }
+  }
+}
+
+query ListWorkWeeks(
+  $filters: WorkWeekFilterInput
+  $limit: Int
+  $skip: Int
+  $sort: WorkWeekSortInput
+) {
+  workWeeks(filters: $filters, limit: $limit, skip: $skip, sort: $sort) {
+    rows {
+      id
+      companyId
+      employeeId
+      officeId
+      effectiveFrom
+      effectiveTo
+      duration
+      timezone
+      monday {
+        working
+        duration
+      }
+      tuesday {
+        working
+        duration
+      }
+      wednesday {
+        working
+        duration
+      }
+      thursday {
+        working
+        duration
+      }
+      friday {
+        working
+        duration
+      }
+      saturday {
+        working
+        duration
+      }
+      sunday {
+        working
+        duration
+      }
+    }
+    count
+    next
+  }
+}

package/src/hooks/index.ts

@@ -0,0 +1,3 @@
+export { useCurrentEmployeeId } from './useCurrentEmployeeId';
+export { useLeaveList, type LeaveListItem } from './useLeaveList';
+export { useBalance, type BalanceData } from './useBalance';

package/src/hooks/useBalance.ts

@@ -0,0 +1,58 @@
+import { useSuspenseQuery } from '@tanstack/react-query';
+import { leaveQueries, policyQueries } from '../queries';
+import { isDefined } from '../utils/typeSafeUtils';
+import { useCurrentEmployeeId } from './useCurrentEmployeeId';
+
+export interface BalanceData {
+  remaining: number;
+  spent: number;
+  saved: number | null;
+  unpaid: number | null;
+}
+
+/**
+ * Fetches the current employee's vacation balance and policy,
+ * returning normalized tile values.
+ *
+ * Returns `null` when no balance data exists.
+ *
+ * Norwegian policies (`includeUnusedDaysInNewBalance`) use
+ * `balanceAmountPlusUnpaidLeft` for remaining and omit saved/unpaid
+ * (returned as `null`).
+ */
+export function useBalance(): BalanceData | null {
+  const employeeId = useCurrentEmployeeId();
+
+  const { data: balanceData } = useSuspenseQuery(
+    leaveQueries.balanceList({
+      filters: { employeeId: { eq: employeeId } },
+    })
+  );
+
+  const rows = (balanceData.employeeVacationBalanceList?.rows ?? []).filter(isDefined);
+
+  const balance = rows[0];
+  const leavePolicyId = balance?.leavePolicyId ?? '';
+
+  const { data: policyData } = useSuspenseQuery(policyQueries.detail(leavePolicyId));
+
+  if (!balance) return null;
+
+  const isNorwegian = policyData.leavePolicy?.allowance?.includeUnusedDaysInNewBalance === true;
+
+  if (isNorwegian) {
+    return {
+      remaining: balance.balanceAmountPlusUnpaidLeft ?? 0,
+      spent: balance.spentAmount ?? 0,
+      saved: null,
+      unpaid: null,
+    };
+  }
+
+  return {
+    remaining: balance.balanceAmount ?? 0,
+    spent: balance.spentAmount ?? 0,
+    saved: balance.savedDaysLeft ?? 0,
+    unpaid: balance.balanceAmountUnpaidLeft ?? 0,
+  };
+}

package/src/hooks/useCurrentEmployeeId.ts

@@ -0,0 +1,15 @@
+import { useSuspenseQuery } from '@tanstack/react-query';
+import { userQueries } from '../queries';
+
+/**
+ * Resolves the current user's employeeId from the Gateway `me` query.
+ */
+export function useCurrentEmployeeId(): string {
+  const { data } = useSuspenseQuery(userQueries.me());
+  const employeeId = data.me.membership?.employeeId;
+
+  if (!employeeId) {
+    throw new Error('Current user has no employeeId');
+  }
+  return employeeId;
+}

package/src/hooks/useLeaveList.ts

@@ -0,0 +1,91 @@
+import { useSuspenseQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { leaveQueries, policyQueries } from '../queries';
+import type { DisplayStatus, LeaveChangeType } from '../utils/leaveStatusUtils';
+import { resolveDisplayStatus } from '../utils/leaveStatusUtils';
+import { getLocalToday, splitLeaveSections } from '../utils/splitLeaveSectionsUtils';
+import { isDefined } from '../utils/typeSafeUtils';
+import { useCurrentEmployeeId } from './useCurrentEmployeeId';
+
+export interface LeaveListItem {
+  id: string;
+  typeName: string;
+  displayStatus: DisplayStatus;
+  localStartDate: string;
+  localEndDate: string | null;
+}
+
+/**
+ * Fetches and merges all leave data sources into a unified list
+ * split into upcoming and history sections.
+ *
+ * Resolves the current employee internally — no args needed.
+ *
+ * Data sources:
+ * 1. Standard leaves (HR Core) — has type.name directly
+ * 2. Self-certified leaves (Gateway) — needs typeId→typeName join
+ * 3. Leave changes (Gateway) — for status overrides (pending change/revoke)
+ * 4. Employee leave types (HR Core) — provides typeId→typeName mapping
+ */
+export function useLeaveList(): {
+  upcoming: LeaveListItem[];
+  history: LeaveListItem[];
+} {
+  const employeeId = useCurrentEmployeeId();
+
+  const { data: standardData } = useSuspenseQuery(leaveQueries.listVisible());
+  const { data: selfCertifiedData } = useSuspenseQuery(leaveQueries.selfCertifiedListVisible());
+  const { data: changesData } = useSuspenseQuery(
+    leaveQueries.approvalQueue({ filters: { status: { eq: 'PENDING' } } })
+  );
+  const { data: leaveTypesData } = useSuspenseQuery(policyQueries.employeeLeaveTypes(employeeId));
+
+  return useMemo(() => {
+    // 1. Build typeId → typeName map from employee leave types
+    const typeMap = new Map<string, string>();
+    for (const lt of leaveTypesData.employeeLeaveTypeList) {
+      if (lt?.id) {
+        typeMap.set(lt.id, lt.name);
+      }
+    }
+
+    // 2. Build leaveId → changeType map from pending leave changes
+    const changeMap = new Map<string, LeaveChangeType>();
+    for (const change of changesData.leaveChangeList.data) {
+      const changeType = change.type as LeaveChangeType;
+      if (changeType === 'UPDATE' || changeType === 'REVOKE') {
+        for (const leaveId of change.leaveIds) {
+          changeMap.set(leaveId, changeType);
+        }
+      }
+    }
+
+    // 3. Normalize standard leaves
+    const standardItems: LeaveListItem[] = standardData.leaveListVisible
+      .filter(isDefined)
+      .map(item => ({
+        id: item.id ?? '',
+        typeName: item.type.name,
+        displayStatus: resolveDisplayStatus(item.id ?? '', item.status, changeMap),
+        localStartDate: item.localStartDate,
+        localEndDate: item.localEndDate,
+      }));
+
+    // 4. Normalize self-certified leaves (resolve typeName via map)
+    const selfCertifiedItems: LeaveListItem[] = selfCertifiedData.leaveSelfCertifiedListVisible.data
+      .filter(item => item.status !== 'MIGRATED')
+      .map(item => ({
+        id: item.id,
+        typeName: typeMap.get(item.typeId) ?? item.typeId,
+        displayStatus: resolveDisplayStatus(item.id, item.status, changeMap),
+        localStartDate: item.localStartDate,
+        localEndDate: item.localEndDate ?? null,
+      }));
+
+    // 5. Merge and split into sections
+    const allItems = [...standardItems, ...selfCertifiedItems];
+    const today = getLocalToday();
+
+    return splitLeaveSections(allItems, today);
+  }, [standardData, selfCertifiedData, changesData, leaveTypesData]);
+}

package/src/i18n/index.ts

@@ -0,0 +1,2 @@
+export { initLeaveI18n, getLeaveI18n, resetLeaveI18n } from './instance';
+export { Locale, supportedLocales, resolveLocale } from './locale';

package/src/i18n/instance.ts

@@ -0,0 +1,52 @@
+import i18next, { type i18n } from 'i18next';
+import { Locale, supportedLocales } from './locale';
+
+/**
+ * SINGLETON SCOPE CONSTRAINT (ADR-011):
+ * Same single-consumer constraint as kyInstance/clientConfig in execute.ts.
+ * Shared across all MF remotes importing @leave/core. Safe today (sole consumer).
+ */
+let instance: i18n | null = null;
+
+export async function initLeaveI18n(locale: string = Locale.EN): Promise<i18n> {
+  if (instance) {
+    // Support locale change via remount (not hot-swap — see §12b Runtime Contracts)
+    if (instance.language !== locale) {
+      await instance.changeLanguage(locale);
+    }
+    return instance;
+  }
+
+  instance = i18next.createInstance();
+
+  await instance.init({
+    compatibilityJSON: 'v4',
+    lng: locale,
+    fallbackLng: Locale.EN,
+    supportedLngs: supportedLocales as string[],
+    load: 'currentOnly',
+    interpolation: { escapeValue: false },
+    resources: {
+      'en-GB': {
+        translation: (await import('./translations/en-GB.json')).default,
+      },
+      // Phase 2: uncomment when sv translations are complete
+      // sv: {
+      //   translation: (await import('./translations/sv.json')).default,
+      // },
+    },
+  });
+
+  return instance;
+}
+
+export function getLeaveI18n(): i18n {
+  if (!instance) {
+    throw new Error('[LeavePackage] Leave i18n not initialized. Call initLeaveI18n() first.');
+  }
+  return instance;
+}
+
+export function resetLeaveI18n(): void {
+  instance = null;
+}

package/src/i18n/locale.ts

@@ -0,0 +1,23 @@
+export const Locale = {
+  EN: 'en-GB',
+  SV: 'sv-SE',
+  NB: 'nb-NO',
+  DA: 'da-DK',
+  FI: 'fi-FI',
+} as const;
+
+export type Locale = (typeof Locale)[keyof typeof Locale];
+
+export const supportedLocales: readonly Locale[] = Object.values(Locale);
+
+const LanguageCodeToLocale: Readonly<Record<string, Locale>> = {
+  en: Locale.EN,
+  sv: Locale.SV,
+  nb: Locale.NB,
+  da: Locale.DA,
+  fi: Locale.FI,
+};
+
+export function resolveLocale(input: string): Locale {
+  return LanguageCodeToLocale[input] ?? Locale.EN;
+}

package/src/i18n/translations/en-GB.json

@@ -0,0 +1,67 @@
+{
+  "errors": {
+    "UNEXPECTED_ERROR": {
+      "title": "Something went wrong",
+      "description": "An unexpected error occurred. Please try again."
+    },
+    "CONNECTION_FAILURE": {
+      "title": "Connection failed",
+      "description": "Unable to reach the server. Check your connection and try again."
+    },
+    "BAD_REQUEST": {
+      "title": "Invalid request",
+      "description": "The request could not be processed."
+    },
+    "NOT_FOUND": {
+      "title": "Not found",
+      "description": "The requested resource was not found."
+    },
+    "SYSTEM_FAILURE": {
+      "title": "Server error",
+      "description": "A server error occurred. Please try again later."
+    },
+    "UNAUTHORIZED": {
+      "title": "Session expired",
+      "description": "Your session has expired. Please sign in again."
+    },
+    "FORBIDDEN": {
+      "title": "Access denied",
+      "description": "You do not have permission to access this resource."
+    }
+  },
+  "retry": "Retry",
+  "close": "Close",
+  "balance": {
+    "remaining": {
+      "label": "Remaining",
+      "subtitle": "vacation days"
+    },
+    "spent": {
+      "label": "Spent",
+      "subtitle": "vacation days"
+    },
+    "saved": {
+      "label": "Saved",
+      "subtitle": "vacation days"
+    },
+    "unpaid": {
+      "label": "Unpaid",
+      "subtitle": "days left"
+    }
+  },
+  "leave": {
+    "upcoming": "Upcoming",
+    "history": "History",
+    "emptyTitle": "No leave requests",
+    "emptyDescription": "Your leave requests will appear here",
+    "ongoing": "ongoing",
+    "status": {
+      "APPROVED": "Approved",
+      "PENDING": "Pending",
+      "DENIED": "Denied",
+      "CANCELLED": "Cancelled",
+      "PENDING_CHANGES": "Pending changes",
+      "PENDING_REVOKE": "Pending revoke"
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+export { initializeClient, resetClient, execute } from './client';
+export type { ClientConfig } from './client';
+
+export { initLeaveI18n, getLeaveI18n, resetLeaveI18n } from './i18n';
+export { Locale, supportedLocales, resolveLocale } from './i18n';
+
+export {
+  LeaveError,
+  AuthError,
+  GraphQLError,
+  NetworkError,
+  DomainError,
+  classifyError,
+  ErrorCode,
+  getErrorCode,
+  isHttpError,
+  isRetryable,
+  getErrorMessage,
+} from './errors';

package/src/mutations/index.ts

@@ -0,0 +1,2 @@
+// TODO: leave mutation factories (createLeave, updateLeave, deleteLeave, etc.)
+export {};

package/src/queries/employeeQueryFactory.ts

@@ -0,0 +1,97 @@
+import { queryOptions } from '@tanstack/react-query';
+import { execute } from '../client';
+import type {
+  ListEmploymentsQueryVariables,
+  GetWorkWeekQueryVariables,
+  ListCompanyHolidaysQueryVariables,
+  ListPublicHolidaysQueryVariables,
+  ListRestrictedDatesQueryVariables,
+} from '../graphql';
+import {
+  GetEmployeeDocument,
+  GetEmploymentDocument,
+  ListEmploymentsDocument,
+  GetWorkWeekDocument,
+  ListCompanyHolidaysDocument,
+  ListPublicHolidaysDocument,
+  ListRestrictedDatesDocument,
+} from '../graphql';
+
+export const employeeQueries = {
+  all: ['employee'] as const,
+
+  details: () => [...employeeQueries.all, 'detail'] as const,
+  detail: (id: string) =>
+    queryOptions({
+      queryKey: [...employeeQueries.details(), id] as const,
+      queryFn: ({ signal }) =>
+        execute.hrCore({
+          query: GetEmployeeDocument,
+          variables: { id },
+          signal,
+        }),
+    }),
+
+  employments: () => [...employeeQueries.all, 'employment'] as const,
+  employment: (id: string) =>
+    queryOptions({
+      queryKey: [...employeeQueries.employments(), id] as const,
+      queryFn: ({ signal }) =>
+        execute.hrCore({
+          query: GetEmploymentDocument,
+          variables: { id },
+          signal,
+        }),
+    }),
+  employmentList: (variables: ListEmploymentsQueryVariables) =>
+    queryOptions({
+      queryKey: [...employeeQueries.employments(), 'list', variables] as const,
+      queryFn: ({ signal }) =>
+        execute.hrCore({
+          query: ListEmploymentsDocument,
+          variables,
+          signal,
+        }),
+    }),
+
+  workWeeks: () => [...employeeQueries.all, 'work-week'] as const,
+  workWeek: (variables: GetWorkWeekQueryVariables) =>
+    queryOptions({
+      queryKey: [...employeeQueries.workWeeks(), variables] as const,
+      queryFn: ({ signal }) => execute.hrCore({ query: GetWorkWeekDocument, variables, signal }),
+    }),
+
+  holidays: () => [...employeeQueries.all, 'holiday'] as const,
+  companyHolidays: (variables: ListCompanyHolidaysQueryVariables) =>
+    queryOptions({
+      queryKey: [...employeeQueries.holidays(), 'company', variables] as const,
+      queryFn: ({ signal }) =>
+        execute.hrCore({
+          query: ListCompanyHolidaysDocument,
+          variables,
+          signal,
+        }),
+    }),
+  publicHolidays: (variables: ListPublicHolidaysQueryVariables) =>
+    queryOptions({
+      queryKey: [...employeeQueries.holidays(), 'public', variables] as const,
+      queryFn: ({ signal }) =>
+        execute.hrCore({
+          query: ListPublicHolidaysDocument,
+          variables,
+          signal,
+        }),
+    }),
+
+  restrictedDates: () => [...employeeQueries.all, 'restricted-date'] as const,
+  restrictedDateList: (variables: ListRestrictedDatesQueryVariables) =>
+    queryOptions({
+      queryKey: [...employeeQueries.restrictedDates(), variables] as const,
+      queryFn: ({ signal }) =>
+        execute.hrCore({
+          query: ListRestrictedDatesDocument,
+          variables,
+          signal,
+        }),
+    }),
+};

package/src/queries/index.ts

@@ -0,0 +1,5 @@
+export { leaveQueries } from './leaveQueryFactory';
+export { policyQueries } from './policyQueryFactory';
+export { employeeQueries } from './employeeQueryFactory';
+export { settingsQueries } from './settingsQueryFactory';
+export { userQueries } from './userQueryFactory';