prow-authority 3.6.3

package/src/helpers/authority.ts

@@ -0,0 +1,216 @@
+import Authority from '@beseif-solutions/prow-authority-for-services';
+import { User } from '../v1/types/admin/user-types';
+import { Organization } from '../v1/types/admin/organization-types';
+import { Service } from '../v1/types/admin/service-types';
+import { Quota } from '../v1/types/services/service-types';
+import { UserOrganization, UserOrganizationRole } from '../v1/types/admin/user-organization-types';
+import nconf from "./config";
+
+export enum LicenseLimitNames {
+  Seats = `organization.seats`,
+}
+
+export enum NotificationEventNames {
+  OrganizationAdded = `organization_added`,
+  OrganizationRemoved = `organization_removed`,
+  MemberAdded = `member_added`,
+  MemberRemoved = `member_removed`,
+  MemberInvited = `member_invited`,
+  BillingChanged = `billing_changed`,
+  ServiceAccessWarning = `service_access_warning`,
+  ServiceAccessBlocked = `service_access_blocked`,
+  LicenseLimitApproaching = `license_limit_approaching`,
+  LicenseLimitReached = `license_limit_reached`,
+  LicenseUpgraded = `license_upgraded`,
+  LicenseDowngraded = `license_downgraded`,
+  LicenseDowngradeScheduled = `license_downgrade_scheduled`,
+  PowerUpAdded = `powerup_added`,
+  PowerUpRemoved = `powerup_removed`,
+  InvoiceEmitted = `invoice_emitted`,
+  TrialEnded = `trial_ended`,
+  TrialEndingSoon = `trial_ending_soon`,
+}
+
+export type OrganizationAdded = {
+  cta: {
+    dashboard: string, // organization dashboard
+    preferences: string, // notifications settings
+  },
+  organization: Organization,
+};
+
+export type OrganizationRemoved = {
+  cta: {
+    dashboard: string, // remaining organizations
+    preferences: string, // notifications settings
+  },
+  organization: Organization,
+};
+
+export type MemberAdded = {
+  user: User,
+  role: string,
+  organization: Organization,
+  cta: {
+    members: string, // manage members
+    preferences: string, // notification preferences
+  },
+};
+
+export type MemberRemoved = {
+  user: User,
+  organization: Organization,
+  cta: {
+    members: string, // manage members
+    preferences: string, // notification preferences
+  },
+};
+
+export type MemberInvited = {
+  role: string,
+  organization: Organization,
+  cta: {
+    organizations: string, // organization dashboard
+    preferences: string, // notification preferences
+  },
+};
+
+export type BillingChanged = {
+  organization: Organization,
+  cta: {
+    billing: string, // billing settings
+    preferences: string, // notification preferences
+  },
+};
+
+export type ServiceAccessWarning = {
+  days: number,
+  organization: Organization,
+  cta: {
+    usage: string, // usage
+    preferences: string, // notification preferences
+  },
+};
+
+export type ServiceAccessBlocked = {
+  organization: Organization,
+  service: Service,
+  cta: {
+    usage: string, // usage
+    upgrade: string, // upgrade plan
+    preferences: string, // notification preferences
+  },
+};
+
+export type LicenseLimitApproaching = {
+  limit: Quota & { percentage: number },
+  organization: Organization,
+  cta: {
+    upgrade: string, // upgrade plan
+    preferences: string, // notification preferences
+  },
+};
+
+export type LicenseLimitReached = {
+  limit: Quota,
+  organization: Organization,
+  cta: {
+    upgrade: string, // upgrade plan
+    preferences: string, // notification preferences
+  },
+};
+
+export type LicenseUpgraded = {
+  organization: Organization,
+  cta: {
+    dashboard: string, // organization dashboard
+    preferences: string, // notification preferences
+  },
+};
+
+export type LicenseDowngraded = {
+  organization: Organization,
+  cta: {
+    dashboard: string, // organization dashboard
+    preferences: string, // notification preferences
+  },
+};
+
+export type LicenseDowngradeScheduled = {
+  organization: Organization,
+  scheduled_date: string, // date when the downgrade takes effect
+  cta: {
+    subscription: string, // manage subscription
+    preferences: string, // notification preferences
+  },
+};
+
+export type PowerUpAdded = {
+  organization: Organization,
+  cta: {
+    dashboard: string, // organization dashboard
+    preferences: string, // notification preferences
+  },
+};
+
+export type PowerUpRemoved = {
+  organization: Organization,
+  cta: {
+    dashboard: string, // organization dashboard
+    preferences: string, // notification preferences
+  },
+};
+
+export type InvoiceEmitted = {
+  organization: Organization,
+  invoice: { number: string, amount: number },
+  cta: {
+    preferences: string, // notification preferences
+  },
+};
+
+export type TrialEnded = {
+  organization: Organization,
+  cta: {
+    subscription: string, // review/choose plan
+    billing: string, // add payment method
+    preferences: string, // notification preferences
+  },
+};
+
+export type TrialEndingSoon = {
+  organization: Organization,
+  end_date: string, // date the trial ends
+  cta: {
+    subscription: string, // review/choose plan
+    billing: string, // add payment method
+    preferences: string, // notification preferences
+  },
+};
+
+export type ResourceModelName = `organization.seat` | `organization.organization`;
+
+export const omnipotentAccess = (user: User, organization: Organization): UserOrganization => ({
+  id: 0,
+  user: user.id,
+  organization: organization.id,
+  role: UserOrganizationRole.Owner,
+  invite: null,
+  invited_by: null,
+  preferences: {},
+  created_date: organization.created_date,
+  modified_date: organization.modified_date,
+  enabled: true,
+  metadata: { omnipotent: true },
+});
+
+const authority = new Authority<{
+  license: { limits: LicenseLimitNames },
+  notifications: { events: NotificationEventNames },
+}>({
+  host: nconf.get(`SERVICES:AUTHORITY:HOST`),
+  uuid: nconf.get(`SERVICES:AUTHORITY:UUID`),
+  token: nconf.get(`SERVICES:AUTHORITY:TOKEN`),
+});
+
+export default authority;

package/src/helpers/config.ts

@@ -0,0 +1,4 @@
+import { YamlParser } from '@beseif-solutions/utility-functions/dist/utils/string-utils';
+
+const nconf = new YamlParser({ path: __dirname, filename: `../../config/config.yaml` });
+export default nconf;

package/src/helpers/holded.ts

@@ -0,0 +1,105 @@
+import { Requester } from "@beseif-solutions/utility-functions/dist/utils/http-utils";
+import nconf from "./config";
+
+class Holded {
+
+  private readonly apikey = nconf.get(`SERVICES:HOLDED:APIKEY`);
+
+  private readonly configuration = {
+    baseURL: `https://api.holded.com`,
+    headers: {
+      "Key": this.apikey,
+    },
+  } as const;
+
+  public readonly getInvoice = async (id: string): Promise<{ id: string, docNumber: string }> => {
+    try {
+      const response = await Requester.get(`/api/invoicing/v1/documents/invoice/${id}`, this.configuration);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly getInvoicePDF = async (id: string): Promise<{ status: number, data: string }> => {
+    try {
+      const response = await Requester.get(`/api/invoicing/v1/documents/invoice/${id}/pdf`, this.configuration);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly listContacts = async (params: { customId?: string }): Promise<Holded.Contact[]> => {
+    try {
+      const response = await Requester.get(`/api/invoicing/v1/contacts?${new URLSearchParams(params).toString()}`, this.configuration);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly createContact = async (params: Holded.AddContact): Promise<Holded.Contact> => {
+    try {
+      const response = await Requester.post(`/api/invoicing/v1/contacts`, params, this.configuration);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly updateContacts = async (id: string, params: Partial<Holded.AddContact>): Promise<Holded.Contact> => {
+    try {
+      const response = await Requester.put(`/api/invoicing/v1/contacts/${id}`, params, this.configuration);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly createAccount = async (params: { name: string, prefix: number }): Promise<Holded.Account> => {
+    try {
+      const account = await Requester.post(`/api/accounting/v1/account`, params, this.configuration) as { accountId: string };
+
+      const response = await Requester.get(`/api/invoicing/v1/expensesaccounts/${account.accountId}`, this.configuration);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly updateAccount = async (id: string, params: { name: string }): Promise<Holded.Account> => {
+    try {
+      await Requester.put(`/api/invoicing/v1/expensesaccounts/${id}`, params, this.configuration) as { status: number, info: string, id: string };
+
+      const response = await Requester.get(`/api/invoicing/v1/expensesaccounts/${id}`, this.configuration);
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const holded = new Holded();
+export default holded;
+
+export namespace Holded {
+
+  export type Contact = { id: string, clientRecord: { num: number, name: string } };
+
+  export type AddContact = {
+    customId: string,
+    name: string,
+    code: string,
+    email: string,
+    phone: string,
+    type: `supplier` | `debtor` | `creditor` | `client` | `lead`,
+    isperson: boolean,
+    clientRecord?: number,
+    billAddress: {
+      address: string,
+      city: string,
+      postalCode: string,
+      province: string,
+      country: string,
+    },
+  };
+
+  export type Account = {
+    id: string,
+    name: string,
+    color: string,
+    accountNum: number,
+  };
+
+  export type AddAccount = {
+    prefix: number,
+    name: string,
+  };
+}

package/src/helpers/mysql.ts

@@ -0,0 +1,15 @@
+import { MySQL } from "@beseif-solutions/utility-functions/dist/utils/sql-utils";
+import nconf from "./config";
+
+const mysql = new MySQL({
+  host: nconf.get(`SERVICES:RDS:URL`),
+  port: nconf.get(`SERVICES:RDS:PORT`),
+  user: nconf.get(`SERVICES:RDS:USER`),
+  password: nconf.get(`SERVICES:RDS:PASSWORD`),
+  database: nconf.get(`SERVICES:RDS:DATABASE`),
+  connectionLimit: 5,
+  connectTimeout: 10000,
+});
+export default mysql;
+
+

package/src/helpers/notifications.ts

@@ -0,0 +1,55 @@
+import { Requester } from "@beseif-solutions/utility-functions/dist/utils/http-utils";
+import nconf from "./config";
+import { RequireMinOne } from "@beseif-solutions/utility-functions/dist/utils/typing-utils";
+
+type GmailNotification = RequireMinOne<{
+  to: string[],
+  cc: string[],
+  bcc: string[],
+}> & {
+  locale?: string,
+  template: string,
+  arguments: Record<string, any>,
+  attachments?: {
+    name: string,
+    type: string,
+    content: string,
+  }[],
+};
+
+type SlackNotification = {
+  channels?: string[],
+  messages: string[],
+};
+
+class Notifications {
+
+  private readonly config = async () => ({
+    baseURL: nconf.get(`SERVICES:NOTIFICATIONS:URL`),
+    headers: {
+      [nconf.get(`SERVICES:NOTIFICATIONS:AUTHORIZATION:HEADER`)]: nconf.get(`SERVICES:NOTIFICATIONS:AUTHORIZATION:TOKEN`),
+      "Content-Type": `application/json`,
+    },
+  });
+
+  public readonly gmail = async (params: GmailNotification): Promise<any> => {
+    try {
+      return await Requester.post(`/api/v1/gmail`, {
+        from: nconf.get(`SERVICES:NOTIFICATIONS:NAME`),
+        ...params,
+      }, await this.config());
+    } catch (e) { throw e; }
+  };
+
+  public readonly slack = async (params: SlackNotification): Promise<any> => {
+    try {
+      return await Requester.post(`/api/v1/slack`, {
+        name: nconf.get(`SERVICES:NOTIFICATIONS:NAME`),
+        ...params,
+      }, await this.config());
+    } catch (e) { throw e; }
+  };
+}
+
+const notifications = new Notifications();
+export default notifications;

package/src/helpers/random.ts

@@ -0,0 +1,18 @@
+import crypto from 'crypto';
+
+export const NUMERIC_CHARSET = `0123456789`;
+export const LOWER_CHAR_CHARSET = `abcdefghijklmnopqrstuvwxyz`;
+export const UPPER_CHAR_CHARSET = `ABCDEFGHIJKLMNOPQRSTUVWXYZ`;
+export const SPECIAL_CHARSET = `-./#`;
+export const ALPHA_CHARSET = `${LOWER_CHAR_CHARSET}${UPPER_CHAR_CHARSET}`;
+export const ALPHANUMERIC_CHARSET = `${ALPHA_CHARSET}${NUMERIC_CHARSET}`;
+export const ALL_CHARSET = `${ALPHANUMERIC_CHARSET}${SPECIAL_CHARSET}`;
+
+export const generateRandomString = (charset: string, length: number): string => {
+  if (length <= 0) { throw new Error(`Length must be greater than 0`); }
+  if (!charset) { throw new Error(`Charset cannot be empty`); }
+
+  return new Array(length).fill(``)
+    .map(() => charset[crypto.randomInt(0, charset.length)])
+    .join(``);
+};

package/src/helpers/s3.ts

@@ -0,0 +1,43 @@
+import { S3 } from "@beseif-solutions/utility-functions/dist/utils/file-utils";
+import nconf from "./config";
+
+const s3 = new S3({
+  keyId: nconf.get(`SERVICES:S3:ACCESSKEY`),
+  secret: nconf.get(`SERVICES:S3:SECRETACCESSKEY`),
+  region: nconf.get(`SERVICES:S3:REGION`),
+});
+
+type Entity = `users` | `organizations` | `services`;
+type Names = `avatar` | `cover`;
+
+type Config = {
+  entity: Entity,
+  uuid: string,
+  name: Names,
+};
+
+export const uploadFile = async (config: Config, content: string): Promise<string> => {
+  try {
+    const upload = await s3.upload({
+      bucket: nconf.get(`SERVICES:S3:BUCKET`),
+      path: `prow-authority/${config.entity}/${config.uuid}`,
+      acl: `public-read`,
+      name: config.name,
+      content: {
+        type: `application/x-octet-stream`,
+        data: content,
+      },
+    });
+    return upload.url;
+  } catch (e) { throw e; }
+};
+
+export const deleteFile = async (config: Config): Promise<void> => {
+  try {
+    await s3.delete({
+      bucket: nconf.get(`SERVICES:S3:BUCKET`),
+      path: `prow-authority/${config.entity}/${config.uuid}`,
+      name: config.name,
+    });
+  } catch (e) { throw e; }
+};

package/src/helpers/stripe.ts

@@ -0,0 +1,8 @@
+import Stripe from "stripe";
+import nconf from "./config";
+
+const stripe = new Stripe(nconf.get(`SERVICES:STRIPE:APIKEY`), {
+  apiVersion: `2025-08-27.basil`,
+});
+
+export default stripe;

package/src/index.ts

@@ -0,0 +1,47 @@
+import 'colors';
+import http from 'http';
+import App from './App';
+import nconf from './helpers/config';
+
+
+console.log(`Starting prow-authority server`.yellow, (new Date()).toLocaleString());
+
+const DEFAULT_PORT = 3000;
+
+const normalizePort = (val: number | string): number | string | boolean => {
+  const p: number = (typeof val === `string`) ? parseInt(val, 10) : val;
+  if (isNaN(p)) { return val; } else if (p >= 0) { return p; } else { return false; }
+};
+
+const onError = (error: NodeJS.ErrnoException): void => {
+  if (error.syscall !== `listen`) { throw error; }
+  const bind = (typeof port === `string`) ? `Pipe ` + port : `Port ${port}`;
+  switch (error.code) {
+    case `EACCES`:
+      console.error(`${bind} requires elevated privileges`);
+      process.exit(1);
+      break;
+    case `EADDRINUSE`:
+      console.error(`${bind} is already in use`);
+      process.exit(1);
+      break;
+    default:
+      throw error;
+  }
+};
+
+const onListening = (): void => {
+  const addr = server.address();
+  const bind = (typeof addr === `string`) ? `pipe ${addr}` : `port ${addr.port}`;
+  const now = new Date();
+  console.log(`${now.toLocaleDateString()} ${now.toLocaleTimeString()}: Listening on ${bind}`.cyan);
+};
+
+const port = normalizePort(nconf.get(`SERVICES:PORT`) || DEFAULT_PORT);
+App.set(`port`, port);
+
+const server = http.createServer(App);
+server.listen(port);
+server.on(`error`, onError);
+server.on(`listening`, onListening);
+

package/src/v1/common-types.ts

@@ -0,0 +1,12 @@
+
+export type Modifiers = {
+  order?: {
+    by: string | string[],
+    direction: `descendent` | `ascendent`,
+  },
+  limit?: {
+    from?: string,
+    count: string,
+  },
+  timeout?: string,
+};

package/src/v1/controllers/admin/accounting-seat-controller.ts

@@ -0,0 +1,148 @@
+import { Date2, Formats } from "@beseif-solutions/utility-functions/dist/utils/date-utils";
+import { JSON2 } from "@beseif-solutions/utility-functions/dist/utils/json-utils";
+import { Where } from "@beseif-solutions/utility-functions/dist/utils/sql-utils";
+import { newUUIDv4 } from "@beseif-solutions/utility-functions/dist/utils/string-utils";
+// typing-utils not required here
+import { Validator } from "@beseif-solutions/utility-functions/dist/utils/validation-utils";
+import APIError, { StatusCodes } from "../../../helpers/api-error";
+import accountingSeatDao from "../../daos/accounting-seat-dao";
+import { addAccountingSeatSchema, updateAccountingSeatSchema } from "../../schemas/admin/accounting-seat-schemas";
+import { AccountingSeat, DBRecord } from "../../types/admin/accounting-seat-types";
+import { Modifiers } from "../../common-types";
+
+type Add = Omit<AccountingSeat, `id` | `uuid`>;
+type Update = Partial<Add>;
+
+class AccountingSeatCtrl {
+  public readonly get = async (id: number): Promise<AccountingSeat[]> => {
+    try {
+      const db = await accountingSeatDao.get({ id: id });
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly list = async (params: Where<DBRecord>, options: Modifiers = {}): Promise<AccountingSeat[]> => {
+    try {
+      const db = await accountingSeatDao.list({ ...params }, options);
+      const response = await this.parse(db);
+      return response;
+    } catch (e) { throw e; }
+  };
+
+  public readonly add = async (data: Add): Promise<AccountingSeat[]> => {
+    try {
+      await Validator.validateAsync(addAccountingSeatSchema, data);
+
+      const uuid = await this.getFreeUUID();
+
+      const { insertId } = await accountingSeatDao.add({
+        uuid: uuid,
+        organization: data.organization,
+        invoice: data.invoice || null,
+        date: data.date,
+        amount: data.amount,
+        done: data.done || false,
+        metadata: data.metadata || {},
+        internal: data.internal || {},
+      } as any);
+
+      return await this.get(insertId);
+    } catch (e) { throw e; }
+  };
+
+  public readonly update = async (id: number, data: Update): Promise<AccountingSeat[]> => {
+    try {
+      await Validator.validateAsync(updateAccountingSeatSchema, data);
+
+      const old = (await this.get(id))[0];
+      if (!old) {
+        throw new APIError({ code: StatusCodes.NOT_FOUND, detail: `Billing seat with id ${id} not found.` });
+      }
+
+      const merged = JSON2.deepClean(JSON2.deepMerge({}, old, data)) as AccountingSeat;
+
+      const { affectedRows } = await accountingSeatDao.update({ id: id }, {
+        uuid: merged.uuid,
+        organization: merged.organization,
+        invoice: merged.invoice,
+        date: merged.date,
+        amount: merged.amount,
+        done: merged.done,
+        metadata: merged.metadata,
+        internal: merged.internal,
+      } as any);
+
+      if (affectedRows <= 0) {
+        throw new APIError({ code: StatusCodes.INTERNAL_SERVER_ERROR, detail: `Could not update billing seat with id ${id}` });
+      }
+
+      return await this.get(id);
+    } catch (e) { throw e; }
+  };
+
+  public readonly delete = async (id: number): Promise<{ deleted: boolean }> => {
+    try {
+      const seat = (await this.get(id))[0];
+      if (!seat) {
+        throw new APIError({ code: StatusCodes.NOT_FOUND, detail: `Billing seat with id ${id} not found.` });
+      }
+
+      const { affectedRows } = await accountingSeatDao.delete({ id: seat.id });
+
+      if (affectedRows <= 0) {
+        throw new APIError({ code: StatusCodes.INTERNAL_SERVER_ERROR, detail: `Could not delete billing seat with id ${id}` });
+      }
+
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  public readonly deleteIf = async (params: Where<DBRecord>): Promise<{ deleted: boolean }> => {
+    try {
+      const { affectedRows } = await accountingSeatDao.deleteIf(params);
+
+      if (affectedRows <= 0) {
+        throw new APIError({ code: StatusCodes.INTERNAL_SERVER_ERROR, detail: `Could not delete billing seats` });
+      }
+
+      return { deleted: affectedRows > 0 };
+    } catch (e) { throw e; }
+  };
+
+  private readonly getFreeUUID = async (): Promise<string> => {
+    try {
+      let uuid: string;
+      do {
+        uuid = newUUIDv4({ case: `lower` });
+        const exists = (await accountingSeatDao.list({ uuid: uuid } as any))[0];
+        if (!exists) { break; }
+      } while (true);
+      return uuid;
+    } catch (e) { throw e; }
+  };
+
+  private readonly parse = async (records: DBRecord[]): Promise<AccountingSeat[]> => {
+    try {
+      const response: AccountingSeat[] = [];
+      for (const record of records) {
+        const p: AccountingSeat = {
+          id: record.id,
+          uuid: record.uuid,
+          organization: record.organization,
+          invoice: record.invoice,
+          date: new Date2(record.date).format(Formats.ISO),
+          amount: parseFloat(record.amount as any),
+          done: (record.done as any) === 1,
+          metadata: record.metadata,
+          internal: record.internal,
+        };
+        response.push(p);
+      }
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+const accountingSeatController = new AccountingSeatCtrl();
+export default accountingSeatController;