@dev.smartpricing/platform-layer 0.0.2

package/_shared/permissions.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod'
+
+const BundleSchema = z.object({
+  enabled: z.boolean(),
+})
+
+export const PermissionsResponseSchema = z.object({
+  products: z.object({
+    pricing: BundleSchema,
+    connect: BundleSchema,
+    chat: BundleSchema,
+    smartpms: BundleSchema,
+  }),
+})
+
+export type PermissionsResponse = z.infer<typeof PermissionsResponseSchema>

package/_shared/products.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod'
+
+export const SuiteProductSchema = z.enum(['pms', 'pricing', 'chat', 'connect'])
+
+export const SuiteLinkSchema = z.object({
+  value: SuiteProductSchema,
+  /** Bold "Smart" prefix shown in the brand-dark color. */
+  prefix: z.string(),
+  /** Suffix shown in the violet brand color (e.g. "pms", "pricing"). */
+  suffix: z.string(),
+  /** Translation key for the tagline shown under the product name. */
+  taglineKey: z.string(),
+})
+
+export const OrgProductStatusSchema = z.enum(['active', 'trial', 'not_subscribed'])
+
+/**
+ * Billing context surfaced when a paying customer cannot access a product —
+ * lets the UI explain *why* access is blocked (e.g. an unpaid invoice).
+ */
+export const ProductBlockedReasonSchema = z.object({
+  hasActiveSubscription: z.boolean(),
+  daysOverdue: z.number().nullable(),
+  oldestUnpaidDueDate: z.string().nullable(),
+})
+
+export const OrgProductRowSchema = SuiteLinkSchema.extend({
+  available: z.boolean(),
+  lifecycleMode: z.string().optional(),
+  status: OrgProductStatusSchema,
+  blockedReason: ProductBlockedReasonSchema.optional(),
+})
+
+export const ListSuiteLinksResponseSchema = z.object({
+  items: z.array(SuiteLinkSchema),
+})
+
+export const ListOrgProductsResponseSchema = z.object({
+  items: z.array(OrgProductRowSchema),
+})
+
+export type SuiteProduct = z.infer<typeof SuiteProductSchema>
+export type SuiteLink = z.infer<typeof SuiteLinkSchema>
+export type OrgProductStatus = z.infer<typeof OrgProductStatusSchema>
+export type ProductBlockedReason = z.infer<typeof ProductBlockedReasonSchema>
+export type OrgProductRow = z.infer<typeof OrgProductRowSchema>
+
+export type ListSuiteLinksResponse = z.infer<typeof ListSuiteLinksResponseSchema>
+export type ListOrgProductsResponse = z.infer<typeof ListOrgProductsResponseSchema>

package/_shared/properties.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod'
+import { UuidSchema } from './common.js'
+
+export const PropertySchema = z.object({
+  id: UuidSchema,
+  organizationId: UuidSchema,
+  name: z.string(),
+  location: z.string().nullable().optional(),
+})
+
+export const ListPropertiesResponseSchema = z.object({
+  items: z.array(PropertySchema),
+})
+
+export type Property = z.infer<typeof PropertySchema>
+export type ListPropertiesResponse = z.infer<typeof ListPropertiesResponseSchema>

package/_shared/subscriptionCancellation.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod'
+
+export const SubscriptionCancellationRequestSchema = z.object({
+  legalEntityId: z.string().min(1),
+  subscriptionIds: z.array(z.string().min(1)).min(1),
+  reasons: z.array(z.string()).min(1),
+  otherReasons: z.string(),
+  keepSendingPrices: z.boolean().optional(),
+})
+
+export const SubscriptionCancellationResponseSchema = z.object({
+  emails_status: z.enum(['sent', 'failed']),
+  zapier_status: z.enum(['sent', 'skipped', 'failed']),
+})
+
+export type SubscriptionCancellationRequest = z.infer<typeof SubscriptionCancellationRequestSchema>
+export type SubscriptionCancellationResponse = z.infer<typeof SubscriptionCancellationResponseSchema>

package/_shared/unitTypes.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod'
+import { UuidSchema } from './common.js'
+
+export const UnitTypeSchema = z.object({
+  id: UuidSchema,
+  propertyId: UuidSchema,
+  name: z.string(),
+  numUnits: z.number().int(),
+})
+
+export const ListUnitTypesResponseSchema = z.object({
+  items: z.array(UnitTypeSchema),
+})
+
+export type UnitType = z.infer<typeof UnitTypeSchema>
+export type ListUnitTypesResponse = z.infer<typeof ListUnitTypesResponseSchema>

package/_shared/user.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod'
+import { UuidSchema } from './common.js'
+import { PasswordSchema } from './password.js'
+
+export const UserSchema = z.object({
+  id: UuidSchema,
+  email: z.string().email(),
+  firstName: z.string(),
+  lastName: z.string(),
+  name: z.string(),
+  locale: z.string().nullable(),
+  phone: z.string().nullable(),
+  /** Whether the user has TOTP MFA enabled. Surfaced so the SPA can render the right UI on /account/profile. */
+  mfaEnabled: z.boolean(),
+})
+
+export const LoginRequestSchema = z.object({
+  email: z.string().email(),
+  password: z.string().min(1),
+})
+
+export const ActivateRequestSchema = z.object({
+  token: z.string().min(1),
+  password: PasswordSchema,
+})
+
+export const ForgotPasswordRequestSchema = z.object({
+  email: z.string().email(),
+})
+
+export const ResetPasswordRequestSchema = z.object({
+  token: z.string().min(1),
+  password: PasswordSchema,
+})
+
+export const AccountingLoginRequestSchema = z.object({
+  accountingToken: z.string().min(1),
+})
+
+export const UpdateProfileRequestSchema = z.object({
+  firstName: z.string().trim().min(1).optional(),
+  lastName: z.string().trim().min(1).optional(),
+  phone: z.string().nullable().optional(),
+  locale: z.string().nullable().optional(),
+})
+
+export const ChangePasswordRequestSchema = z.object({
+  currentPassword: z.string().min(1),
+  newPassword: PasswordSchema,
+})
+
+export const UpdateProfileResponseSchema = z.object({
+  user: UserSchema,
+})
+
+export const SessionResponseSchema = z.object({
+  user: UserSchema,
+})
+
+export type User = z.infer<typeof UserSchema>
+
+export type LoginRequest = z.infer<typeof LoginRequestSchema>
+
+export type ActivateRequest = z.infer<typeof ActivateRequestSchema>
+
+export type ForgotPasswordRequest = z.infer<typeof ForgotPasswordRequestSchema>
+
+export type ResetPasswordRequest = z.infer<typeof ResetPasswordRequestSchema>
+
+export type AccountingLoginRequest = z.infer<typeof AccountingLoginRequestSchema>
+
+export type UpdateProfileRequest = z.infer<typeof UpdateProfileRequestSchema>
+export type UpdateProfileResponse = z.infer<typeof UpdateProfileResponseSchema>
+
+export type ChangePasswordRequest = z.infer<typeof ChangePasswordRequestSchema>
+
+export type SessionResponse = z.infer<typeof SessionResponseSchema>

package/app/composables/apiClient.composable.ts

@@ -0,0 +1,25 @@
+export function useApiClient() {
+  const { BACKEND_BASE_URL, ENV_CSRF_COOKIE_NAME, PLATFORM_URL } = useRuntimeConfig().public
+
+  return createApiClient({
+    baseURL: BACKEND_BASE_URL as string,
+    csrf: {
+      cookieName: (ENV_CSRF_COOKIE_NAME as string) || 'smt_csrf',
+    },
+    auth: {
+      refreshBaseURL: BACKEND_BASE_URL as string,
+      platformURL: (PLATFORM_URL as string) || '',
+      mfa: {
+        shouldChallenge: (_status: number, data: unknown) => {
+          const code = (data as { error?: { code?: string } } | undefined)?.error?.code
+          return code === 'otp_required'
+        },
+      },
+      onRefreshFailed: () => {
+        if (import.meta.client) {
+          window.location.assign(`${PLATFORM_URL}/auth/login`)
+        }
+      },
+    },
+  })
+}

package/app/composables/useAuth.composable.ts

@@ -0,0 +1,17 @@
+export function useAuth() {
+  const { PLATFORM_URL } = useRuntimeConfig().public
+  const { mutateAsync: logout, status, error } = useLogoutMutation()
+
+  async function signOut() {
+    await logout()
+    if (import.meta.client) {
+      window.location.assign(`${PLATFORM_URL}/auth/login`)
+    }
+  }
+
+  return {
+    signOut,
+    logoutStatus: status,
+    logoutError: error,
+  }
+}

package/app/mutations/useAccountingLogin.mutation.ts

@@ -0,0 +1,10 @@
+import type { AccountingLoginRequest } from '@package/platform-shared'
+
+export function useAccountingLoginMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: AccountingLoginRequest) =>
+      client<void>('/api/auth/accounting-login', { method: 'POST', body }),
+  })
+}

package/app/mutations/useActivate.mutation.ts

@@ -0,0 +1,10 @@
+import type { ActivateRequest } from '@package/platform-shared'
+
+export function useActivateMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: ActivateRequest) =>
+      client<void>('/api/auth/activate', { method: 'POST', body }),
+  })
+}

package/app/mutations/useChangePassword.mutation.ts

@@ -0,0 +1,10 @@
+import type { ChangePasswordRequest } from '@package/platform-shared'
+
+export function useChangePasswordMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: ChangePasswordRequest) =>
+      client<{ ok: true }>('/api/me/change-password', { method: 'POST', body }),
+  })
+}

package/app/mutations/useCreatePaymentMethod.mutation.ts

@@ -0,0 +1,13 @@
+import type { CreatePaymentMethodRequest, CreatePaymentMethodsResponse } from '@package/platform-shared'
+
+export function useCreatePaymentMethodMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (params: { orgId: string; body: CreatePaymentMethodRequest }) =>
+      client<CreatePaymentMethodsResponse>(
+        `/api/orgs/${encodeURIComponent(params.orgId)}/billing/payment-methods`,
+        { method: 'POST', body: params.body },
+      ),
+  })
+}

package/app/mutations/useCreateSetupIntent.mutation.ts

@@ -0,0 +1,13 @@
+import type { CreateSetupIntentRequest, CreateSetupIntentResponse } from '@package/platform-shared'
+
+export function useCreateSetupIntentMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (params: { orgId: string; body: CreateSetupIntentRequest }) =>
+      client<CreateSetupIntentResponse>(
+        `/api/orgs/${encodeURIComponent(params.orgId)}/billing/payment-methods/setup-intent`,
+        { method: 'POST', body: params.body },
+      ),
+  })
+}

package/app/mutations/useLogin.mutation.ts

@@ -0,0 +1,10 @@
+import type { LoginRequest } from '@package/platform-shared'
+
+export function useLoginMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: LoginRequest) =>
+      client<void>('/api/auth/login', { method: 'POST', body }),
+  })
+}

package/app/mutations/useLogout.mutation.ts

@@ -0,0 +1,7 @@
+export function useLogoutMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: () => client<void>('/api/auth/logout', { method: 'POST' }),
+  })
+}

package/app/mutations/useMfaDisable.mutation.ts

@@ -0,0 +1,10 @@
+import type { MfaDisableRequest, MfaDisableResponse } from '@package/platform-shared'
+
+export function useMfaDisableMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: MfaDisableRequest) =>
+      client<MfaDisableResponse>('/api/auth/mfa/disable', { method: 'POST', body }),
+  })
+}

package/app/mutations/useMfaFinalize.mutation.ts

@@ -0,0 +1,10 @@
+import type { MfaFinalizeRequest, MfaFinalizeResponse } from '@package/platform-shared'
+
+export function useMfaFinalizeMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: MfaFinalizeRequest) =>
+      client<MfaFinalizeResponse>('/api/auth/mfa/finalize', { method: 'POST', body }),
+  })
+}

package/app/mutations/useMfaRegenerateRecoveryCodes.mutation.ts

@@ -0,0 +1,10 @@
+import type { MfaRegenerateRecoveryCodesRequest, MfaRegenerateRecoveryCodesResponse } from '@package/platform-shared'
+
+export function useMfaRegenerateRecoveryCodesMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: MfaRegenerateRecoveryCodesRequest) =>
+      client<MfaRegenerateRecoveryCodesResponse>('/api/auth/mfa/regenerate-recovery-codes', { method: 'POST', body }),
+  })
+}

package/app/mutations/useMfaSetup.mutation.ts

@@ -0,0 +1,10 @@
+import type { MfaSetupResponse } from '@package/platform-shared'
+
+export function useMfaSetupMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: () =>
+      client<MfaSetupResponse>('/api/auth/mfa/setup', { method: 'POST' }),
+  })
+}

package/app/mutations/useMfaStepUp.mutation.ts

@@ -0,0 +1,10 @@
+import type { MfaStepUpRequest, MfaStepUpResponse } from '@package/platform-shared'
+
+export function useMfaStepUpMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: MfaStepUpRequest) =>
+      client<MfaStepUpResponse>('/api/auth/otp', { method: 'POST', body }),
+  })
+}

package/app/mutations/useRefresh.mutation.ts

@@ -0,0 +1,7 @@
+export function useRefreshMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: () => client<void>('/api/auth/refresh', { method: 'POST' }),
+  })
+}

package/app/mutations/useRemovePaymentMethod.mutation.ts

@@ -0,0 +1,11 @@
+export function useRemovePaymentMethodMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (params: { orgId: string; paymentMethodId: string }) =>
+      client<void>(
+        `/api/orgs/${encodeURIComponent(params.orgId)}/billing/payment-methods/${encodeURIComponent(params.paymentMethodId)}`,
+        { method: 'DELETE' },
+      ),
+  })
+}

package/app/mutations/useRequestLegalEntityChange.mutation.ts

@@ -0,0 +1,13 @@
+import type { RequestLegalEntityChangeRequest } from '@package/platform-shared'
+
+export function useRequestLegalEntityChangeMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (params: { orgId: string; id: string; body: RequestLegalEntityChangeRequest }) =>
+      client<{ emails_status: 'sent' | 'failed' }>(
+        `/api/orgs/${encodeURIComponent(params.orgId)}/billing/legal-entities/${encodeURIComponent(params.id)}/change-request`,
+        { method: 'POST', body: params.body },
+      ),
+  })
+}

package/app/mutations/useRequestPasswordReset.mutation.ts

@@ -0,0 +1,10 @@
+import type { ForgotPasswordRequest } from '@package/platform-shared'
+
+export function useRequestPasswordResetMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: ForgotPasswordRequest) =>
+      client<void>('/api/auth/request-password-reset', { method: 'POST', body }),
+  })
+}

package/app/mutations/useRequestSubscriptionCancellation.mutation.ts

@@ -0,0 +1,13 @@
+import type { SubscriptionCancellationRequest, SubscriptionCancellationResponse } from '@package/platform-shared'
+
+export function useRequestSubscriptionCancellationMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (params: { orgId: string; body: SubscriptionCancellationRequest }) =>
+      client<SubscriptionCancellationResponse>(
+        `/api/orgs/${encodeURIComponent(params.orgId)}/subscriptions/request-cancellation`,
+        { method: 'POST', body: params.body },
+      ),
+  })
+}

package/app/mutations/useResetPassword.mutation.ts

@@ -0,0 +1,10 @@
+import type { ResetPasswordRequest } from '@package/platform-shared'
+
+export function useResetPasswordMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: ResetPasswordRequest) =>
+      client<void>('/api/auth/reset-password', { method: 'POST', body }),
+  })
+}

package/app/mutations/useSetPrimaryPaymentMethod.mutation.ts

@@ -0,0 +1,13 @@
+import type { SetPrimaryPaymentMethodRequest, SetPrimaryPaymentMethodResponse } from '@package/platform-shared'
+
+export function useSetPrimaryPaymentMethodMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (params: { orgId: string; body: SetPrimaryPaymentMethodRequest }) =>
+      client<SetPrimaryPaymentMethodResponse>(
+        `/api/orgs/${encodeURIComponent(params.orgId)}/billing/payment-methods/primary`,
+        { method: 'PATCH', body: params.body },
+      ),
+  })
+}

package/app/mutations/useUpdateLegalEntity.mutation.ts

@@ -0,0 +1,13 @@
+import type { UpdateLegalEntityRequest, LegalEntityDetail } from '@package/platform-shared'
+
+export function useUpdateLegalEntityMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (params: { orgId: string; id: string; body: UpdateLegalEntityRequest }) =>
+      client<LegalEntityDetail>(
+        `/api/orgs/${encodeURIComponent(params.orgId)}/billing/legal-entities/${encodeURIComponent(params.id)}`,
+        { method: 'PATCH', body: params.body },
+      ),
+  })
+}

package/app/mutations/useUpdateProfile.mutation.ts

@@ -0,0 +1,10 @@
+import type { UpdateProfileRequest, UpdateProfileResponse } from '@package/platform-shared'
+
+export function useUpdateProfileMutation() {
+  const client = useApiClient()
+
+  return useMutation({
+    mutation: (body: UpdateProfileRequest) =>
+      client<UpdateProfileResponse>('/api/me', { method: 'PATCH', body }),
+  })
+}

package/app/queries/useBillingDocumentPdf.query.ts

@@ -0,0 +1,22 @@
+import type { BillingDocumentPdfResponse, BillingDocumentType } from '@package/platform-shared'
+
+export const billingDocumentPdfKeys = {
+  byId: (orgId: string, type: BillingDocumentType, id: string) =>
+    ['billing', 'document-pdf', orgId, type, id] as const,
+}
+
+export function useBillingDocumentPdfQuery(
+  orgId: MaybeRefOrGetter<string>,
+  type: MaybeRefOrGetter<BillingDocumentType>,
+  id: MaybeRefOrGetter<string>,
+) {
+  const client = useApiClient()
+
+  return useQuery({
+    key: () => billingDocumentPdfKeys.byId(toValue(orgId), toValue(type), toValue(id)),
+    query: () => client<BillingDocumentPdfResponse>(
+      `/api/orgs/${encodeURIComponent(toValue(orgId))}/billing/documents/${toValue(type)}/${encodeURIComponent(toValue(id))}/pdf`,
+    ),
+    enabled: () => !!toValue(orgId) && !!toValue(id),
+  })
+}

package/app/queries/useBillingDocuments.query.ts

@@ -0,0 +1,35 @@
+import type { ListBillingDocumentsResponse } from '@package/platform-shared'
+
+export interface BillingDocumentsQueryParams {
+  legalEntityId?: string
+  customerId?: string
+  limit?: number
+  after?: string
+  before?: string
+  subscriptionIds?: string[]
+  type?: string
+  status?: string[]
+  search?: string
+}
+
+export const billingDocumentsKeys = {
+  all: (orgId: string) => ['billing', 'documents', orgId] as const,
+  byOrg: (orgId: string, params?: BillingDocumentsQueryParams) =>
+    ['billing', 'documents', orgId, JSON.stringify(params)] as const,
+}
+
+export function useBillingDocumentsQuery(
+  orgId: MaybeRefOrGetter<string>,
+  params?: MaybeRefOrGetter<BillingDocumentsQueryParams | undefined>,
+) {
+  const client = useApiClient()
+
+  return useQuery({
+    key: () => billingDocumentsKeys.byOrg(toValue(orgId), toValue(params)),
+    query: () => client<ListBillingDocumentsResponse>(
+      `/api/orgs/${encodeURIComponent(toValue(orgId))}/billing/documents`,
+      { query: toValue(params) },
+    ),
+    enabled: () => !!toValue(orgId),
+  })
+}

package/app/queries/useBillingOverview.query.ts

@@ -0,0 +1,17 @@
+import type { BillingOverviewResponse } from '@package/platform-shared'
+
+export const billingOverviewKeys = {
+  byOrg: (orgId: string) => ['billing', 'overview', orgId] as const,
+}
+
+export function useBillingOverviewQuery(orgId: MaybeRefOrGetter<string>) {
+  const client = useApiClient()
+
+  return useQuery({
+    key: () => billingOverviewKeys.byOrg(toValue(orgId)),
+    query: () => client<BillingOverviewResponse>(
+      `/api/orgs/${encodeURIComponent(toValue(orgId))}/billing`,
+    ),
+    enabled: () => !!toValue(orgId),
+  })
+}

package/app/queries/useCrossSelling.query.ts

@@ -0,0 +1,14 @@
+import type { GetCrossSellingResponse } from '@package/platform-shared'
+
+export const crossSellingKeys = {
+  all: () => ['cross-selling'] as const,
+}
+
+export function useCrossSellingQuery() {
+  const client = useApiClient()
+
+  return useQuery({
+    key: crossSellingKeys.all,
+    query: () => client<GetCrossSellingResponse>('/api/me/cross-selling'),
+  })
+}

package/app/queries/useLegalEntity.query.ts

@@ -0,0 +1,20 @@
+import type { LegalEntityDetail } from '@package/platform-shared'
+
+export const legalEntityKeys = {
+  byId: (orgId: string, id: string) => ['legal-entity', orgId, id] as const,
+}
+
+export function useLegalEntityQuery(
+  orgId: MaybeRefOrGetter<string>,
+  id: MaybeRefOrGetter<string>,
+) {
+  const client = useApiClient()
+
+  return useQuery({
+    key: () => legalEntityKeys.byId(toValue(orgId), toValue(id)),
+    query: () => client<LegalEntityDetail>(
+      `/api/orgs/${encodeURIComponent(toValue(orgId))}/billing/legal-entities/${encodeURIComponent(toValue(id))}`,
+    ),
+    enabled: () => !!toValue(orgId) && !!toValue(id),
+  })
+}

package/app/queries/useOrganization.query.ts

@@ -0,0 +1,17 @@
+import type { OrganizationContextResponse } from '@package/platform-shared'
+
+export const organizationKeys = {
+  byId: (orgId: string) => ['organization', orgId] as const,
+}
+
+export function useOrganizationQuery(orgId: MaybeRefOrGetter<string>) {
+  const client = useApiClient()
+
+  return useQuery({
+    key: () => organizationKeys.byId(toValue(orgId)),
+    query: () => client<OrganizationContextResponse>(
+      `/api/orgs/${encodeURIComponent(toValue(orgId))}`,
+    ),
+    enabled: () => !!toValue(orgId),
+  })
+}

package/app/queries/usePermissions.query.ts

@@ -0,0 +1,14 @@
+import type { PermissionsResponse } from '@package/platform-shared'
+
+export const permissionsKeys = {
+  all: () => ['permissions'] as const,
+}
+
+export function usePermissionsQuery() {
+  const client = useApiClient()
+
+  return useQuery({
+    key: permissionsKeys.all,
+    query: () => client<PermissionsResponse>('/api/me/permissions'),
+  })
+}