kasy-cli 1.2.1

package/templates/firebase/functions/src/core/data/entities/notification_entity.ts

@@ -0,0 +1,74 @@
+import {QueryDocumentSnapshot, Timestamp} from "firebase-admin/firestore";
+import {cleanEntityId} from "./entity_utils";
+
+export interface NotificationEntityData {
+    id?: string,
+    title: string;
+    body?: string;
+    type?: NotificationTypes,
+    creation_date: Timestamp;
+    seen_date?: Timestamp;
+    notify_user: boolean;
+    data?: { [key: string]: any },
+    image_url?: string;
+}
+
+export enum NotificationTypes {
+    WELCOME = "WELCOME",
+    OTHER = "OTHER",
+    LINK = "LINK",
+}
+
+export interface NotificationType {
+    type: NotificationTypes;
+}
+
+export type NewNotificationEntityData = Omit<NotificationEntityData, "id">;
+
+export interface NotificationEntity extends NotificationEntityData {}
+
+export class NotificationEntity {
+  constructor({
+    id,
+    title,
+    body,
+    type,
+    creation_date,
+    seen_date,
+    notify_user,
+    data,
+    image_url,
+  }: NotificationEntityData
+  ) {
+    this.id = id;
+    this.title = title;
+    this.body = body;
+    this.type = type;
+    this.creation_date = creation_date;
+    this.seen_date = seen_date;
+    this.notify_user = notify_user;
+    this.data = data;
+    this.image_url = image_url;
+  }
+
+  static fromData(data: NotificationEntityData): NotificationEntity {
+    return new NotificationEntity(data);
+  }
+
+  static fromDocument(data: QueryDocumentSnapshot): NotificationEntity {
+    const resData = data.data() as NotificationEntityData;
+    resData.id = data.id;
+    return new NotificationEntity(resData);
+  }
+}
+
+export class NotificationAdapter {
+  static toMap(data: NewNotificationEntityData): { [key: string]: unknown } {
+    const cleaned = cleanEntityId(data);
+    return {
+      ...cleaned,
+      // seen_date must be explicitly null (not absent) so Firestore isNull queries work for badge counts.
+      seen_date: data.seen_date ?? null,
+    };
+  }
+}

package/templates/firebase/functions/src/core/data/entities/page.ts

@@ -0,0 +1,4 @@
+export interface Page<T> {
+    items: T[];
+    lastSnapshot?: FirebaseFirestore.QueryDocumentSnapshot | undefined;
+}

package/templates/firebase/functions/src/core/data/entities/subscription_entity.ts

@@ -0,0 +1,76 @@
+import {DocumentData, QueryDocumentSnapshot, Timestamp} from "firebase-admin/firestore";
+import {SubscriptionsRepository} from "../repositories/subscription_repository";
+import {Stores, SubscriptionStatus} from "../../../subscriptions/models/subscription_status";
+import {Subscription} from "../../../subscriptions/models/subscriptions";
+
+export interface SubscriptionEntityData {
+    id?: string,
+    creation_date: Timestamp;
+    last_activity: Timestamp;
+    expiration_date?: Timestamp;
+    status: SubscriptionStatus;
+    store: Stores,
+    product_id: string;
+}
+
+export type NewSubscriptionEntityData = Omit<SubscriptionEntityData, "id">;
+
+export interface SubscriptionEntity extends SubscriptionEntityData {}
+
+export class SubscriptionEntity {
+  constructor({
+    id,
+    creation_date,
+    last_activity,
+    expiration_date,
+    status,
+    store,
+    product_id,
+  }: SubscriptionEntityData
+  ) {
+    this.id = id;
+    this.creation_date = creation_date;
+    this.last_activity = last_activity;
+    this.expiration_date = expiration_date;
+    this.status = status;
+    this.store = store;
+    this.product_id = product_id;
+  }
+
+  static fromData(data: SubscriptionEntityData): SubscriptionEntity {
+    return new SubscriptionEntity(data);
+  }
+
+  static fromDocument(data: QueryDocumentSnapshot | DocumentData): SubscriptionEntity {
+    const serieData = <SubscriptionEntityData>{
+      id: data.id,
+      ...data.data(),
+    };
+    return new SubscriptionEntity(serieData);
+  }
+
+  static from(subscription: Subscription): SubscriptionEntity {
+    return new SubscriptionEntity({
+      id: subscription.userId,
+      creation_date: subscription.creationDate,
+      last_activity: subscription.lastUpdate,
+      expiration_date: subscription.expirationDate,
+      status: subscription.status,
+      store: subscription.store,
+      product_id: subscription.productId,
+    });
+  }
+
+  toSubscription(subscriptionRepository: SubscriptionsRepository) {
+    return new Subscription({
+      userId: this.id!,
+      creationDate: this.creation_date,
+      lastUpdate: this.last_activity,
+      expirationDate: this.expiration_date,
+      status: this.status,
+      store: this.store,
+      productId: this.product_id,
+    }, subscriptionRepository);
+  }
+}
+

package/templates/firebase/functions/src/core/data/entities/user_device_entity.ts

@@ -0,0 +1,64 @@
+import {QueryDocumentSnapshot, Timestamp} from "firebase-admin/firestore";
+import {cleanEntityId} from "./entity_utils";
+
+export const UserDevice = {
+  ANDROID: "android",
+  IOS: "ios",
+  WEB: "WEB",
+} as const;
+
+export type UserDeviceTypes = (typeof UserDevice)[keyof typeof UserDevice];
+
+export interface UserDeviceEntityData {
+    id?: string,
+    token: string;
+    device_id: string;
+    operatingSystem: UserDeviceTypes;
+    type: UserDeviceTypes;
+    creation_date: Timestamp;
+    extra_data?: { [key: string]: string };
+}
+
+export type NewUserDeviceEntityData = Omit<UserDeviceEntityData, "id">;
+
+export interface UserDeviceEntity extends UserDeviceEntityData {}
+
+export class UserDeviceEntity {
+  constructor({
+    id,
+    token,
+    device_id,
+    type,
+    operatingSystem,
+    creation_date,
+    extra_data,
+  }: UserDeviceEntityData
+  ) {
+    this.id = id;
+    this.token = token;
+    this.device_id = device_id;
+    this.type = type;
+    this.operatingSystem = operatingSystem;
+    this.creation_date = creation_date;
+    this.extra_data = extra_data;
+  }
+
+  static fromData(data: UserDeviceEntityData): UserDeviceEntity {
+    return new UserDeviceEntity(data);
+  }
+
+  static fromDocument(data: QueryDocumentSnapshot): UserDeviceEntity {
+    const resData = data.data() as UserDeviceEntityData;
+    resData.id = data.id;
+    return new UserDeviceEntity(resData);
+  }
+}
+
+export class UserDeviceAdapter {
+  static toMap(data: UserDeviceEntityData): { [key: string]: unknown } {
+    const cleanData = cleanEntityId(data);
+    return {
+      ...cleanData,
+    };
+  }
+}

package/templates/firebase/functions/src/core/data/entities/user_entity.ts

@@ -0,0 +1,43 @@
+import {DocumentSnapshot, QueryDocumentSnapshot, Timestamp} from "firebase-admin/firestore";
+
+export interface UserEntityData {
+    id?: string,
+    name?: string;
+    email?: string;
+    creation_date: Timestamp;
+    last_update_date: Timestamp;
+    locale?: string;
+}
+
+export type NewUserEntityData = Omit<UserEntityData, "id">;
+
+export interface UserEntity extends UserEntityData {}
+
+export class UserEntity {
+  constructor({
+    id,
+    name,
+    email,
+    creation_date,
+    last_update_date,
+    locale
+  }: UserEntityData
+  ) {
+    this.id = id;
+    this.name = name;
+    this.email = email;
+    this.creation_date = creation_date;
+    this.last_update_date = last_update_date;
+    this.locale = locale;
+  }
+
+  static fromData(data: UserEntityData): UserEntity {
+    return new UserEntity(data);
+  }
+
+  static fromDocument(data: QueryDocumentSnapshot | DocumentSnapshot): UserEntity {
+    const result = data.data() as UserEntityData;
+    result.id = data.id;
+    return new UserEntity(result);
+  }
+}

package/templates/firebase/functions/src/core/data/repositories/repositories.ts

@@ -0,0 +1,16 @@
+import {SubscriptionsRepository} from "./subscription_repository";
+import {UserDevicesRepository} from "./user_device_repository";
+import {UserNotificationsRepository} from "./user_notifications_repository";
+import {UserRepository} from "./user_repository";
+import * as admin from "firebase-admin";
+
+// One of the best practices for cloud function is
+// Use global variables to reuse objects in future invocations
+// https://firebase.google.com/docs/functions/tips#use_global_variables_to_reuse_objects_in_future_invocations
+
+const firestore = admin.firestore();
+
+export const usersRepository = new UserRepository(firestore);
+export const notificationsRepository = new UserNotificationsRepository(firestore);
+export const userDevicesRepository = new UserDevicesRepository(firestore);
+export const subscriptionsRepository = new SubscriptionsRepository(firestore);

package/templates/firebase/functions/src/core/data/repositories/subscription_repository.ts

@@ -0,0 +1,42 @@
+import {Subscription} from "../../../subscriptions/models/subscriptions";
+import {cleanEntityId} from "../entities/entity_utils";
+import {SubscriptionEntity, SubscriptionEntityData} from "../entities/subscription_entity";
+
+export class SubscriptionsRepository {
+  constructor(
+        private db: FirebaseFirestore.Firestore,
+  ) { }
+
+  private collection() {
+    return this.db.collection("subscriptions");
+  }
+
+  private document(userid: string) {
+    return this.collection().doc(userid);
+  }
+
+  async save(subscription: Subscription): Promise<void> {
+    await this.document(subscription.userId).set(
+      SubscriptionAdapter.toMap(SubscriptionEntity.from(subscription))
+    );
+  }
+
+  async getFromUserId(userId: string): Promise<Subscription | null> {
+    const snapshot= await this.document(userId).get();
+    if (!snapshot.exists) {
+      return null;
+    }
+    const entity = SubscriptionEntity.fromDocument(snapshot);
+    return entity.toSubscription(this);
+  }
+}
+
+
+export class SubscriptionAdapter {
+  static toMap(data: SubscriptionEntityData): { [key: string]: unknown } {
+    const cleanData = cleanEntityId({...data});
+    return {
+      ...cleanData,
+    };
+  }
+}

package/templates/firebase/functions/src/core/data/repositories/user_device_repository.ts

@@ -0,0 +1,31 @@
+import {UserDeviceAdapter, UserDeviceEntity} from "../entities/user_device_entity";
+
+export class UserDevicesRepository {
+  constructor(
+        private db: FirebaseFirestore.Firestore,
+  ) { }
+
+  private collection(userId: string) {
+    return this.db
+      .collection("users")
+      .doc(userId)
+      .collection("devices")
+      .withConverter({
+        fromFirestore: UserDeviceEntity.fromDocument,
+        toFirestore: (device: UserDeviceEntity) => UserDeviceAdapter.toMap(device),
+      });
+  }
+
+  async getDevices(userIds: string[]): Promise<UserDeviceEntity[]> {
+    const result: UserDeviceEntity[] = [];
+    for (const userId of userIds) {
+      const userResult = await this.collection(userId).get();
+      result.push(...userResult.docs.map((doc) => doc.data()));
+    }
+    return result;
+  }
+
+  async delete(userId: string, deviceId: string): Promise<void> {
+    await this.collection(userId).doc(deviceId).delete();
+  }
+}

package/templates/firebase/functions/src/core/data/repositories/user_notifications_repository.ts

@@ -0,0 +1,58 @@
+import {NotificationEntity, NotificationAdapter} from "../entities/notification_entity";
+
+
+export class UserNotificationsRepository {
+  constructor(
+        private db: FirebaseFirestore.Firestore,
+  ) { }
+
+  private collection(userId: string) {
+    return this.db
+      .collection("users")
+      .doc(userId)
+      .collection("notifications")
+      .withConverter({
+        fromFirestore: (snapshot: FirebaseFirestore.QueryDocumentSnapshot) => {
+          return NotificationEntity.fromDocument(snapshot);
+        },
+        toFirestore: (notification: NotificationEntity) => NotificationAdapter.toMap(notification),
+      });
+  }
+
+  async save(userId: string, notification: NotificationEntity): Promise<NotificationEntity> {
+    const res = await this.collection(userId).add(notification);
+    notification.id = res.id;
+    return notification;
+  }
+
+  async getLast(userId: string): Promise<NotificationEntity | undefined> {
+    const res = await this.collection(userId)
+      .orderBy("creation_date", "desc")
+      .limit(1)
+      .get();
+    if (res.empty) {
+      return undefined;
+    }
+    return res.docs[0].data();
+  }
+
+  async saveAll(userIds: string[], notifications: NotificationEntity): Promise<void> {
+    const chunkSize = 500;
+    const processedUserIds: string[] = [];
+    while (processedUserIds.length < userIds.length) {
+      const chunk = userIds.slice(processedUserIds.length, processedUserIds.length + chunkSize);
+      const batch = this.db.batch();
+      try {
+        for (const userId of chunk) {
+          const userRef = this.collection(userId);
+          batch.create(userRef.doc(), notifications);
+        }
+        await batch.commit();
+      } catch (e) {
+        console.error(e);
+        throw Error("Error saving notifications");
+      }
+      processedUserIds.push(...chunk);
+    }
+  }
+}

package/templates/firebase/functions/src/core/data/repositories/user_repository.ts

@@ -0,0 +1,84 @@
+import {cleanEntityId} from "../entities/entity_utils";
+import { Timestamp } from "firebase-admin/firestore";
+import {Page} from "../entities/page";
+import {UserEntity, UserEntityData} from "../entities/user_entity";
+
+export class UserRepository {
+  constructor(
+        private db: FirebaseFirestore.Firestore,
+  ) { }
+
+  private collection() {
+    return this.db.collection("users")
+      .withConverter({
+        fromFirestore: (snapshot: FirebaseFirestore.QueryDocumentSnapshot) => {
+          return UserEntity.fromDocument(snapshot);
+        },
+        toFirestore: (user: UserEntity) => UserAdapter.toMap(user),
+      });
+  }
+
+  async create(user: UserEntity): Promise<UserEntity> {
+    const userEntityWithoutId = cleanEntityId({...user});
+    await this.collection().doc(user.id!).set(userEntityWithoutId);
+    return user;
+  }
+
+  async getFromId(userId: string) {
+    const snapshot = await this.collection()
+      .doc(userId)
+      .get();
+    if (!snapshot.exists) {
+      return null;
+    }
+    return UserEntity.fromDocument(snapshot);
+  }
+
+  async update(user: UserEntity) {
+    const userEntityWithoutId = cleanEntityId({ ...user });
+    await this.collection().doc(user.id!).set(userEntityWithoutId);
+  }
+
+  async updateEmail(userId: string, email: string) {
+    await this.collection().doc(userId).update({
+      email,
+      "last_update_date": Timestamp.now(),
+    });
+  }
+
+  async list({
+    limit = 100,
+    startAfter,
+  }: {
+        limit?: number,
+        startAfter?: FirebaseFirestore.DocumentSnapshot,
+    }) : Promise<Page<UserEntity>> {
+    let query = this.collection()
+      .orderBy("creation_date", "asc");
+    if (startAfter) {
+      query = query.startAfter(startAfter);
+    }
+    if (limit) {
+      query = query.limit(limit);
+    }
+    return query
+      .get()
+      .then((snapshot) => {
+        if (snapshot.empty) {
+          return <Page<UserEntity>>{items: []};
+        }
+        const entities = snapshot.docs.map((doc) => UserEntity.fromDocument(doc));
+        return <Page<UserEntity>>{
+          items: entities,
+          lastSnapshot: snapshot.docs[snapshot.docs.length - 1],
+        };
+      });
+  }
+}
+
+export class UserAdapter {
+  static toMap(entity: UserEntityData): { [key: string]: unknown } {
+    const cleanedEntity = cleanEntityId({...entity});
+    return cleanedEntity;
+  }
+}

package/templates/firebase/functions/src/core/logger/logger.ts

@@ -0,0 +1,13 @@
+import * as functions from "firebase-functions";
+
+export class Logger {
+  constructor(private className: string) {}
+
+  info(message: string) {
+    functions.logger.info(`[${this.className}] ${message}`);
+  }
+
+  error(message: string, error?: Error | unknown ) {
+    functions.logger.error(`[${this.className}] ${message}`, error);
+  }
+}

package/templates/firebase/functions/src/core/storage/storage_manager.ts

@@ -0,0 +1,52 @@
+/* eslint @typescript-eslint/no-var-requires: 0 */
+
+import * as Storage from "@google-cloud/storage";
+import * as fs from "fs";
+import * as os from "os";
+import * as crypto from "crypto";
+const spawn = require("child-process-promise").spawn;
+
+
+export class StorageUploader {
+  constructor(
+        private bucket: Storage.Bucket,
+  ) { }
+
+  async uploadImg(
+    imgPath: string,
+    destinationPath: string,
+    thumbnailPath: string
+  ): Promise<[Storage.File, Storage.File]> {
+    if (!imgPath) {
+      throw new Error("imgFile is null");
+    }
+    const highRes = await this.uploadFileFromPath(imgPath, destinationPath);
+    await spawn("convert", [imgPath, "-thumbnail", "200x200>", imgPath]);
+    const thumbnail = await this.uploadFileFromPath(imgPath, thumbnailPath);
+    fs.unlinkSync(imgPath);
+    return [highRes, thumbnail];
+  }
+
+  async uploadFile(file: File, destinationPath: string): Promise<Storage.File> {
+    const tmpImgPath = `${os.tmpdir()}/tmp-${crypto.randomBytes(8).toString("hex")}.jpg`;
+    fs.writeFileSync(tmpImgPath, Buffer.from(await file.arrayBuffer()));
+    const res = await this.uploadFileFromPath(tmpImgPath, destinationPath);
+    fs.unlinkSync(tmpImgPath);
+    return res;
+  }
+
+  async uploadFileFromPath(
+    filePath: string,
+    destinationPath: string,
+    contentType = "image/jpeg",
+  ): Promise<Storage.File> {
+    await this.bucket.upload(filePath, {
+      destination: destinationPath,
+      metadata: {
+        contentType: contentType,
+      },
+    });
+    const uploadedFile = this.bucket.file(destinationPath);
+    return uploadedFile;
+  }
+}

package/templates/firebase/functions/src/core/utils/async_utils.ts

@@ -0,0 +1,5 @@
+export function delay(time: number) {
+  return new Promise(function(_) {
+    setTimeout(_, time);
+  });
+}

package/templates/firebase/functions/src/feature_requests/triggers.ts

@@ -0,0 +1,3 @@
+// Vote counter is updated atomically by the client via WriteBatch.
+// Cloud Function triggers are not needed and have been removed to avoid double-counting.
+export {};

package/templates/firebase/functions/src/index.ts

@@ -0,0 +1,24 @@
+import * as admin from "firebase-admin";
+import {setGlobalOptions} from "firebase-functions/v2";
+
+// Initialize functions preferred region (replaced by kasy at project generation)
+setGlobalOptions({region: "europe-west1"});
+
+admin.initializeApp();
+
+// authentications
+exports.authTriggers = require("./authentication/triggers");
+exports.authFunctions = require("./authentication/functions");
+
+// notifications
+exports.notificationsTriggers = require("./notifications/triggers");
+exports.notificationsFunctions = require("./notifications/admin_functions");
+
+// subscriptions
+exports.subscriptions = require("./subscriptions/subscriptions_functions");
+exports.subscriptionTriggers = require("./subscriptions/triggers");
+
+// feature requests: vote counter updated atomically by client (WriteBatch)
+
+// llm chat proxy (activated when withLlmChat = true)
+exports.llmChat = require("./llm_chat").llmChat;