prow-authority 3.6.3

package/src/v1/schemas/billing/billing-schemas.ts

@@ -0,0 +1,32 @@
+import { Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { InvoiceStatus } from "../../types/admin/invoice-types";
+
+export const generateOrganizationInvoiceSchema = Schema.object({
+  current_date: Schema.date({ strict: false, format: Formats.ISO }),
+});
+
+export const getInvoicesSchema = Schema.object({
+  status: Schema.string({ valid: Object.values(InvoiceStatus) }),
+  current_date: Schema.date({ strict: false, format: Formats.ISO }),
+});
+
+export const invoiceEmittedSchema = (free: boolean) =>
+  Schema.object({
+    invoice: free ? Schema.string() : Schema.requiredString(),
+  });
+
+export const invoicePaidSchema = (free: boolean) =>
+  Schema.object({
+    payment: free ? Schema.string() : Schema.requiredString(),
+    method: free ? Schema.string() : Schema.requiredString(),
+  });
+
+export const updateInvoiceSchema = Schema.object({
+  metadata: Schema.object(),
+});
+
+export const getAccountingSeatsSchema = Schema.object({
+  done: Schema.requiredBool(),
+  current_date: Schema.date({ strict: false, format: Formats.ISO }),
+});

package/src/v1/schemas/organizations/public-organization-schemas.ts

@@ -0,0 +1,77 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const createOrganizationSchema = Schema.object({
+  properties: Schema.requiredObject({
+    name: Schema.requiredString(),
+    activity: Schema.requiredString(),
+    image: Schema.string({ allow: [null] }),
+    cover: Schema.string({ allow: [null] }),
+  }),
+  preferences: Schema.requiredObject({
+    timezone: Schema.requiredString(),
+  }),
+  metadata: Schema.object(),
+});
+
+export const updateOrganizationSchema = Schema.object({
+  properties: Schema.object({
+    name: Schema.string(),
+    activity: Schema.string(),
+    image: Schema.string({ allow: [null] }),
+    cover: Schema.string({ allow: [null] }),
+  }),
+  billing: Schema.object({
+    name: Schema.string(),
+    document: Schema.string(),
+    email: Schema.email(),
+    phone: Schema.string(),
+    address: {
+      address: Schema.string(),
+      city: Schema.string(),
+      zip: Schema.string(),
+      province: Schema.string(),
+      country: Schema.string(),
+    },
+    individual: Schema.bool(),
+  }),
+  preferences: Schema.object({
+    timezone: Schema.string(),
+  }),
+  metadata: Schema.object(),
+});
+
+export const licenseParamsSchema = Schema.object({
+  enabled: Schema.string({ valid: [`true`, `false`] }),
+});
+
+export const activateLicenseSchema = Schema.object({
+  license: Schema.requiredString(),
+  billing: Schema.requiredString({ valid: [`monthly`, `annual`] }),
+  renew: Schema.requiredBool(),
+  scheduled: Schema.bool(),
+  metadata: Schema.object(),
+});
+
+export const activatePowerUpSchema = Schema.object({
+  license: Schema.requiredString(),
+  billing: Schema.requiredString({ valid: [`monthly`, `annual`] }),
+  renew: Schema.requiredBool(),
+  metadata: Schema.object(),
+});
+
+export const addPaymentMethodSchema = Schema.object({
+  payment_method_id: Schema.requiredString(),
+  enabled: Schema.requiredBool(),
+  properties: Schema.object({
+    alias: Schema.string(),
+  }),
+  metadata: Schema.object(),
+});
+
+export const updatePaymentMethodSchema = Schema.object({
+  enabled: Schema.bool(),
+  properties: Schema.object({
+    alias: Schema.string(),
+  }),
+  metadata: Schema.object(),
+});

package/src/v1/schemas/services/public-service-schemas.ts

@@ -0,0 +1,5 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const listLicensesSchema = Schema.object({
+  metadata: Schema.object(),
+});

package/src/v1/schemas/services/service-schemas.ts

@@ -0,0 +1,27 @@
+import { Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+
+export const quotaParamsSchema = Schema.object({
+  date: Schema.date({ strict: false, format: Formats.ISO }),
+  name: Schema.array({ items: Schema.string(), min: 1 }),
+});
+
+export const quotaUsageSchema = Schema.object({
+  name: Schema.requiredString(),
+  count: Schema.requiredNumber(),
+});
+
+export const sendNotificationSchema = Schema.object({
+  event: Schema.requiredString(),
+  locale: Schema.string(),
+  context: Schema.object()
+    .pattern(Schema.string(), Schema.alternatives(Schema.string(), Schema.number())),
+  data: Schema.object(),
+  attachments: Schema.array({
+    items: Schema.object({
+      name: Schema.requiredString(),
+      type: Schema.requiredString(),
+      content: Schema.requiredString(),
+    }),
+  }),
+});

package/src/v1/schemas/users/public-user-schemas.ts

@@ -0,0 +1,73 @@
+import { Schema } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import { UserOrganizationRole } from "../../types/admin/user-organization-types";
+import { CommunicationType } from "../../types/admin/user-types";
+
+export const registerUserSchema = Schema.object({
+  email: Schema.requiredEmail({ max: 200 }),
+  password: Schema.requiredString({ min: 8 }),
+  properties: Schema.requiredObject({
+    name: Schema.requiredString(),
+    surnames: Schema.string(),
+    image: Schema.string(),
+  }),
+  preferences: Schema.requiredObject({
+    language: Schema.requiredString({ length: 2 }),
+    communications: Schema.object({
+      [CommunicationType.Commercial]: Schema.bool(),
+      [CommunicationType.Newsletter]: Schema.bool(),
+    }),
+  }),
+  utm: Schema.object({
+    medium: Schema.string(),
+    source: Schema.string(),
+    campaign: Schema.string(),
+  }),
+  referrer: Schema.string().optional(),
+  metadata: Schema.object(),
+});
+
+export const updateUserSchema = Schema.object({
+  // email: Schema.email({ max: 200 }),
+  password: Schema.string({ min: 8 }),
+  properties: Schema.object({
+    name: Schema.string(),
+    surnames: Schema.string(),
+    image: Schema.string(),
+  }),
+  preferences: Schema.object({
+    language: Schema.string({ length: 2 }),
+    communications: Schema.object({
+      [CommunicationType.Commercial]: Schema.bool(),
+      [CommunicationType.Newsletter]: Schema.bool(),
+    }),
+  }),
+  metadata: Schema.object(),
+});
+
+export const inviteUserSchema = Schema.object({
+  email: Schema.requiredString(),
+  role: Schema.requiredString({ valid: [UserOrganizationRole.Admin, UserOrganizationRole.Staff] }),
+  enabled: Schema.requiredBool(),
+  metadata: Schema.object(),
+});
+
+export const updateUserAccessSchema = Schema.object({
+  role: Schema.string({ valid: [UserOrganizationRole.Admin, UserOrganizationRole.Staff] }),
+  enabled: Schema.bool(),
+  metadata: Schema.object(),
+});
+
+export const updateUserOrganizationSchema = Schema.object({
+  preferences: Schema.object({
+    notifications: Schema.object(),
+  }),
+  metadata: Schema.object(),
+});
+
+export const changeOwnershipSchema = Schema.object({
+  user: Schema.requiredString(),
+});
+
+export const acceptPoliciesSchema = Schema.object({
+  uuids: Schema.array({ items: Schema.string() }),
+});

package/src/v1/types/admin/accounting-seat-types.ts

@@ -0,0 +1,16 @@
+import { Invoice } from "./invoice-types";
+import { Organization } from "./organization-types";
+
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  organization: Organization[`id`],
+  invoice: Invoice[`id`],
+  date: string,
+  amount: number,
+  done: boolean,
+  metadata: Record<string, any>,
+  internal: Record<string, any>,
+};
+
+export type AccountingSeat = DBRecord;

package/src/v1/types/admin/billing-cycle-types.ts

@@ -0,0 +1,14 @@
+import { Organization } from "./organization-types";
+
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  organization: Organization[`id`],
+  trial: boolean,
+  start_date: string,
+  end_date: string,
+  metadata: Record<string, any>,
+  internal: Record<string, any>,
+};
+
+export type BillingCycle = DBRecord;

package/src/v1/types/admin/invoice-types.ts

@@ -0,0 +1,39 @@
+import { Organization } from "./organization-types";
+import { PaymentMethod } from "./payment-method-types";
+
+export enum InvoiceStatus {
+  Pending = `pending`,
+  Emitted = `emitted`,
+  Paid = `paid`,
+}
+
+export type InvoiceConcept = {
+  name: string,
+  description: string,
+  price: number,
+};
+
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  organization: Organization[`id`],
+  date: string,
+  amount: number,
+  tax_code: string,
+  tax_percentage: number,
+  concepts: InvoiceConcept[],
+  billing: Organization[`billing`],
+  status: InvoiceStatus,
+  invoice: string,
+  number?: string,
+  payment: string,
+  method: PaymentMethod[`id`],
+  metadata: Record<string, any>,
+  internal: Record<string, any>,
+};
+
+export type Invoice = DBRecord
+  & {
+    base: number,
+    tax: number,
+  };

package/src/v1/types/admin/license-limit-types.ts

@@ -0,0 +1,16 @@
+import { License } from "./license-types";
+
+export type DBRecord = {
+  id: number,
+  license: License[`id`],
+  name: string,
+  limit: number,
+  period: `monthly` | `lifetime`,
+  monthly_price_abs: number,
+  annual_price_abs: number,
+  overconsume_monthly_price_per_unit: number,
+  overconsume_annual_price_per_unit: number,
+  metadata: Record<string, any>,
+};
+
+export type LicenseLimit = DBRecord;

package/src/v1/types/admin/license-types.ts

@@ -0,0 +1,29 @@
+import { Service } from "./service-types";
+
+export enum LicenseType {
+  Base = `license`,
+  Variant = `power-up`
+}
+
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  service: Service[`id`],
+  type: LicenseType,
+  associated: number,
+  properties: {
+    name: string,
+    description: string,
+  },
+  data: Record<string, any>,
+  created_date: string,
+  modified_date: string,
+  public: boolean,
+  enabled: boolean,
+  metadata: Record<string, any>,
+} & DBPrices;
+
+export type License = Omit<DBRecord, keyof DBPrices> & Prices;
+
+export type DBPrices = { monthly_price: string, annual_price: string };
+export type Prices = { monthly_price: number, annual_price: number };

package/src/v1/types/admin/organization-license-limit-types.ts

@@ -0,0 +1,13 @@
+import { LicenseLimit } from "./license-limit-types";
+import { OrganizationLicense } from "./organization-license-types";
+import { Organization } from "./organization-types";
+
+export type DBRecord = {
+  id: number,
+  organization: Organization[`id`],
+  license: OrganizationLicense[`id`],
+  overconsume: boolean,
+  metadata: Record<string, any>,
+} & Omit<LicenseLimit, `id` | `license` | `metadata`>;
+
+export type OrganizationLicenseLimit = DBRecord;

package/src/v1/types/admin/organization-license-types.ts

@@ -0,0 +1,21 @@
+import { DBPrices, License, Prices } from "./license-types";
+import { Organization } from "./organization-types";
+
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  original: number,
+  organization: Organization[`id`],
+  billing: `monthly` | `annual` | `lifetime`,
+  start_date: string,
+  end_date: string,
+  enabled: boolean,
+  metadata: Record<string, any>,
+  internal: { notified?: boolean } & Record<string, any>,
+}
+  & DBPrices
+  & Omit<License, `id` | `uuid` | `created_date` | `modified_date` | `public` | `enabled` | `metadata`>;
+
+export type OrganizationLicense = Omit<DBRecord, keyof DBPrices> & Prices;
+
+export { Prices, DBPrices } from './license-types';

package/src/v1/types/admin/organization-types.ts

@@ -0,0 +1,60 @@
+export enum OrganizationStatus {
+  Unpaid = `unpaid`,
+  Active = `active`,
+  Blocked = `blocked`,
+}
+
+export type LimitNotification = {
+  approaching: boolean,
+  reached: boolean,
+  lastPercentage: number,
+};
+
+export type ServiceInformation = {
+  blocked: boolean,
+  exceeded_date?: string,
+  notifications: {
+    access: Record<string, boolean>,
+    limits: Record<string, LimitNotification>,
+  },
+};
+
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  properties: {
+    name: string,
+    activity: string,
+    image?: string,
+    cover?: string,
+  },
+  billing?: {
+    name: string,
+    document: string,
+    email: string,
+    phone?: string,
+    address?: {
+      address: string,
+      city: string,
+      zip: string,
+      province: string,
+      country: string,
+    },
+    individual?: boolean,
+  },
+  preferences: {
+    timezone: string,
+  },
+  created_date: string,
+  modified_date: string,
+  status: OrganizationStatus,
+  metadata: Record<string, any>,
+  internal: {
+    customer?: string,
+    contact?: string,
+    services: Record<string, ServiceInformation>,
+    deleted_date?: string,
+  },
+};
+
+export type Organization = DBRecord;

package/src/v1/types/admin/organization-usage-types.ts

@@ -0,0 +1,17 @@
+import { OrganizationLicenseLimit } from "./organization-license-limit-types";
+import { Organization } from "./organization-types";
+import { Service } from "./service-types";
+
+export type DBRecord = {
+  id: number,
+  organization: Organization[`id`],
+  service: Service[`id`],
+  name: OrganizationLicenseLimit[`name`],
+  count: number,
+  date: string,
+};
+
+export type OrganizationUsage = DBRecord;
+
+export type DBSum = { total: string };
+export type Sum = { total: number };

package/src/v1/types/admin/payment-method-types.ts

@@ -0,0 +1,30 @@
+import { Organization } from "./organization-types";
+
+export enum PaymentMethodType {
+  Card = `card`,
+}
+
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  organization: Organization[`id`],
+  type: PaymentMethodType,
+  properties: {
+    alias?: string,
+    name: string,
+    brand?: string,
+    country?: string,
+    exp_year?: number,
+    exp_month?: number,
+  },
+  enabled: boolean,
+  created_date: string,
+  modified_date: string,
+  metadata: Record<string, any>,
+  internal: {
+    payment_method_id: string,
+    fingerprint?: string,
+  },
+};
+
+export type PaymentMethod = DBRecord;

package/src/v1/types/admin/policy-types.ts

@@ -0,0 +1,9 @@
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  name: string,
+  metadata: Record<string, any>,
+  internal: Record<string, any>,
+};
+
+export type Policy = DBRecord;

package/src/v1/types/admin/policy-version-types.ts

@@ -0,0 +1,12 @@
+export type DBRecord = {
+  id: number,
+  policy: number,
+  version: string,
+  url: string,
+  metadata: Record<string, any>,
+  internal: Record<string, any>,
+  created_date: string,
+  effective_date: string,
+};
+
+export type PolicyVersion = DBRecord;

package/src/v1/types/admin/service-notification-types.ts

@@ -0,0 +1,20 @@
+import { UserOrganizationRole } from "./user-organization-types";
+
+export type Scopes = {
+  roles: UserOrganizationRole[],
+};
+
+export type DBRecord = {
+  id: number,
+  service: number,
+  event: string,
+  template: string,
+  scope: Scopes,
+  created_date: string,
+  modified_date: string,
+  default: boolean,
+  enabled: boolean,
+  metadata: Record<string, any>,
+};
+
+export type ServiceNotification = DBRecord;

package/src/v1/types/admin/service-types.ts

@@ -0,0 +1,36 @@
+type Authority = {
+  host: string,
+  user?: {
+    information?: string,
+    // created?: string,
+    deleted?: string,
+  },
+  organization?: {
+    information?: string,
+    created?: string,
+    modified?: string,
+    deleted?: string,
+  },
+};
+
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  properties: {
+    name: string,
+    description: string,
+    home?: string,
+    image: string,
+  },
+  preferences: {
+    // TODO: design preferences, colors, alternative interfaces...
+  },
+  token: string,
+  created_date: string,
+  modified_date: string,
+  enabled: boolean,
+  metadata: Record<string, any>,
+  internal: {} & Authority,
+};
+
+export type Service = DBRecord;

package/src/v1/types/admin/user-organization-types.ts

@@ -0,0 +1,31 @@
+import { Organization } from "./organization-types";
+import { User } from "./user-types";
+
+export enum UserOrganizationRole {
+  Owner = `owner`,
+  Admin = `admin`,
+  Staff = `staff`,
+}
+
+export type ByResourceConfiguration = Record<string, (number | string)[]>;
+
+export type DBRecord = {
+  id: number,
+  user: User[`id`],
+  organization: Organization[`id`],
+  role: UserOrganizationRole,
+  invite: string,
+  invited_by: User[`id`],
+  preferences?: {
+    notifications?: {
+      [key: string]: boolean | ByResourceConfiguration,
+    },
+  },
+  created_date: string,
+  modified_date: string,
+  enabled: boolean,
+  metadata: Record<string, any>,
+};
+
+export type UserOrganization =
+  DBRecord & {};

package/src/v1/types/admin/user-types.ts

@@ -0,0 +1,44 @@
+export enum UserStatus {
+  Pending = `pending`,
+  Active = `active`,
+  Expired = `expired`,
+  Blocked = `blocked`
+}
+
+export enum CommunicationType {
+  Commercial = `commercial`,
+  Newsletter = `newsletter`,
+}
+
+export type UTM = Partial<{
+  medium: string,
+  source: string,
+  campaign: string,
+}>;
+
+export type Communications = Partial<Record<CommunicationType, boolean>>;
+
+export type DBRecord = {
+  id: number,
+  uuid: string,
+  email: string,
+  password: string,
+  properties: {
+    name: string,
+    surnames: string,
+    image?: string,
+  },
+  preferences: {
+    language: string,
+    communications?: Communications,
+  },
+  utm: UTM,
+  referrer?: string,
+  omnipotent: boolean,
+  created_date: string,
+  modified_date: string,
+  status: UserStatus,
+  metadata: Record<string, any>,
+};
+
+export type User = DBRecord;

package/src/v1/types/auth/@deprecated auth-types.ts

@@ -0,0 +1,26 @@
+// oauth authorization
+// export type OAuth = {
+//   id_token: string,
+// } & BearerAuthorization;
+
+// export type StartOAuth = {
+//   client_id: string,
+//   redirect_uri: string,
+//   response_type: string,
+//   scope: string,
+//   access_type: string,
+// };
+
+// export type Exchange = {
+//   client_id: string,
+//   client_secret: string,
+//   grant_type: `authorization_code`,
+//   scope: string,
+//   redirect_uri: string,
+//   code: string,
+// } | {
+//   client_id: string,
+//   client_secret: string,
+//   grant_type: `refresh_token`,
+//   refresh_token: string,
+// };

package/src/v1/types/auth/common-types.ts

@@ -0,0 +1,7 @@
+// bearer authorization
+export type BearerAuthorization = {
+  token_type: `Bearer`,
+  access_token: string,
+  refresh_token?: string,
+  expires_in: number,
+};

package/src/v1/types/auth/confirmation-types.ts

@@ -0,0 +1,5 @@
+export type Confirmation = {
+  code: string,
+  attempts: number,
+  expiration: number,
+};