kasy-cli 1.2.1

package/templates/firebase/functions/src/subscriptions/models/revenuecat_events.ts

@@ -0,0 +1,162 @@
+import {Timestamp} from "firebase-admin/firestore";
+import {SubscriptionStatus} from "./subscription_status";
+
+import * as admin from "firebase-admin";
+
+export const PeriodTypes = {
+  TRIAL: "TRIAL",
+  INTRO: "INTRO",
+  NORMAL: "NORMAL",
+  PROMOTIONAL: "PROMOTIONAL",
+  PREPAID: "PREPAID",
+} as const;
+
+export type PeriodTypes = typeof PeriodTypes[keyof typeof PeriodTypes];
+
+export const RcEventTypes = {
+  TEST: "TEST",
+  INITIAL_PURCHASE: "INITIAL_PURCHASE",
+  RENEWAL: "RENEWAL",
+  CANCELLATION: "CANCELLATION",
+  UNCANCELLATION: "UNCANCELLATION",
+  NON_RENEWING_PURCHASE: "NON_RENEWING_PURCHASE",
+  SUBSCRIPTION_PAUSED: "SUBSCRIPTION_PAUSED",
+  EXPIRATION: "EXPIRATION",
+  BILLING_ISSUE: "BILLING_ISSUE",
+  PRODUCT_CHANGE: "PRODUCT_CHANGE",
+  TRANSFER: "TRANSFER",
+  SUBSCRIPTION_EXTENDED: "SUBSCRIPTION_EXTENDED",
+  TEMPORARY_ENTITLEMENT_GRANT: "TEMPORARY_ENTITLEMENT_GRANT",
+  REFUND_REVERSED: "REFUND_REVERSED",
+  INVOICE_ISSUANCE: "INVOICE_ISSUANCE",
+  VIRTUAL_CURRENCY_TRANSACTION: "VIRTUAL_CURRENCY_TRANSACTION",
+} as const;
+
+export type RcEventTypes = typeof RcEventTypes[keyof typeof RcEventTypes];
+
+// see https://www.revenuecat.com/docs/integrations/webhooks/event-types-and-fields
+
+export interface RevenueCatEventData {
+  event_timestamp_ms: number;
+  product_id: string;
+  period_type?: PeriodTypes;
+  expiration_at_ms: number | null;
+  store: string;
+  app_user_id: string;
+  type: string;
+  new_product_id?: string;
+  currency?: string;
+  price_in_purchased_currency?: number;
+  is_trial_conversion?: boolean;
+}
+
+// deno-lint-ignore no-empty-interface
+export interface RevenueCatEvent extends RevenueCatEventData {}
+
+export class RevenueCatEvent {
+  constructor({
+    event_timestamp_ms,
+    product_id,
+    period_type,
+    expiration_at_ms,
+    store,
+    app_user_id,
+    type,
+    new_product_id,
+    currency,
+    price_in_purchased_currency,
+    is_trial_conversion,
+  }: RevenueCatEventData) {
+    this.event_timestamp_ms = event_timestamp_ms;
+    this.product_id = product_id;
+    this.period_type = period_type;
+    this.expiration_at_ms = expiration_at_ms;
+    this.store = store;
+    this.app_user_id = app_user_id;
+    this.type = type;
+    this.new_product_id = new_product_id;
+    this.currency = currency;
+    this.price_in_purchased_currency = price_in_purchased_currency;
+    this.is_trial_conversion = is_trial_conversion;
+  }
+
+  static fromJson(json: string): RevenueCatEvent {
+    const data = JSON.parse(json);
+    return new RevenueCatEvent({
+      event_timestamp_ms: parseInt(data.event_timestamp_ms),
+      product_id: data.product_id,
+      period_type: data.period_type,
+      expiration_at_ms: data.expiration_at_ms != null ? parseInt(data.expiration_at_ms) : null,
+      store: data.store,
+      app_user_id: data.app_user_id,
+      type: data.type,
+      new_product_id: data.new_product_id,
+      currency: data.currency,
+      price_in_purchased_currency: data.price_in_purchased_currency,
+      is_trial_conversion: data.is_trial_conversion,
+    });
+  }
+
+  static fromData(data: any): RevenueCatEvent {
+    return new RevenueCatEvent({ ...data });
+  }
+
+  get expirationTimestamp(): Timestamp | undefined {
+    const expirationDate = this.expirationDate;
+    if (!expirationDate) {
+      return undefined;
+    }
+    if (this.subscriptionStatus === SubscriptionStatus.LIFETIME) {
+      return undefined;
+    }
+    return admin.firestore.Timestamp.fromMillis(this.expiration_at_ms!);
+  }
+
+  get expirationDate(): Date | undefined {
+    if (this.subscriptionStatus === SubscriptionStatus.LIFETIME) {
+      return undefined;
+    }
+    if (!this.expiration_at_ms) {
+      return undefined;
+    }
+    return new Date(this.expiration_at_ms);
+  }
+
+  get subscriptionStatus(): SubscriptionStatus {
+    switch (this.type) {
+      case "INITIAL_PURCHASE":
+      case "RENEWAL":
+      case "UNCANCELLATION":
+      case "SUBSCRIPTION_EXTENDED":
+      case "PRODUCT_CHANGE":
+        return SubscriptionStatus.ACTIVE;
+      case "CANCELLATION":
+      case "SUBSCRIPTION_PAUSED":
+      case "EXPIRATION":
+        return SubscriptionStatus.EXPIRED;
+      case "NON_RENEWING_PURCHASE":
+        return SubscriptionStatus.LIFETIME;
+    }
+    return SubscriptionStatus.EXPIRED;
+  }
+
+  get shouldIgnore(): boolean {
+    switch (this.type) {
+      case "BILLING_ISSUE":
+      case "TRANSFER":
+      case "TEMPORARY_ENTITLEMENT_GRANT":
+      case "EXPERIMENT_ENROLLMENT":
+      case "REFUND_REVERSED":
+      case "INVOICE_ISSUANCE":
+      case "VIRTUAL_CURRENCY_TRANSACTION":
+        return true;
+    }
+    return false;
+  }
+
+  get isInitialPurchase(): boolean {
+    return (this.type === "INITIAL_PURCHASE" &&
+      this.period_type !== PeriodTypes.TRIAL) ||
+      (this.is_trial_conversion === true);
+  }
+}

package/templates/firebase/functions/src/subscriptions/models/subscription_status.ts

@@ -0,0 +1,18 @@
+export const SubscriptionStatus = {
+  ACTIVE: "ACTIVE",
+  PAUSED: "PAUSED",
+  EXPIRED: "EXPIRED",
+  LIFETIME: "LIFETIME",
+} as const;
+
+type ObjectValues<T> = T[keyof T];
+
+export type SubscriptionStatus = ObjectValues<typeof SubscriptionStatus>;
+
+export const Stores = {
+  PLAY_STORE: "PLAY_STORE",
+  APPLE_STORE: "APPLE_STORE",
+  EARLY_BIRD: "EARLY_BIRD",
+} as const;
+
+export type Stores = ObjectValues<typeof Stores>;

package/templates/firebase/functions/src/subscriptions/models/subscriptions.ts

@@ -0,0 +1,173 @@
+import { Timestamp } from "firebase-admin/firestore";
+import { RevenueCatEvent } from "./revenuecat_events";
+import * as admin from "firebase-admin";
+import { Stores, SubscriptionStatus } from "./subscription_status";
+import { UserRepository } from "../../core/data/repositories/user_repository";
+import { SubscriptionsRepository } from "../../core/data/repositories/subscription_repository";
+import { SubscriptionEntity } from "../../core/data/entities/subscription_entity";
+
+export const subscriptionDuration = {
+  WEEKLY: "WEEKLY",
+  MONTHLY: "MONTHLY",
+  YEARLY: "YEARLY",
+  LIFETIME: "LIFETIME",
+} as const;
+
+export type SubscriptionDuration =
+  (typeof subscriptionDuration)[keyof typeof subscriptionDuration];
+
+export interface SubscriptionData {
+  userId: string;
+  status: SubscriptionStatus;
+  creationDate: Timestamp;
+  lastUpdate: Timestamp;
+  expirationDate?: Timestamp;
+  store: Stores;
+  productId: string;
+}
+
+export interface Subscription extends SubscriptionData {}
+
+export class Subscription {
+  constructor(
+    {
+      userId,
+      status,
+      creationDate,
+      lastUpdate,
+      expirationDate,
+      store,
+      productId,
+    }: SubscriptionData,
+    private subscriptionRepository: SubscriptionsRepository,
+  ) {
+    this.userId = userId;
+    this.status = status;
+    this.creationDate = creationDate;
+    this.lastUpdate = lastUpdate;
+    this.expirationDate = expirationDate;
+    this.store = store;
+    this.productId = productId;
+  }
+
+  static async fromRevenueCat({
+    event,
+    userRepository,
+    subscriptionRepository,
+  }: {
+    event: RevenueCatEvent;
+    userRepository: UserRepository;
+    subscriptionRepository: SubscriptionsRepository;
+  }): Promise<Subscription> {
+    const user = await userRepository.getFromId(event.app_user_id);
+    if (!user || !user.id) {
+      throw new Error(`User ${event.app_user_id} not found`);
+    }
+    const subscription = await subscriptionRepository.getFromUserId(user.id);
+    const now = admin.firestore.Timestamp.now();
+    if (!subscription) {
+        return new Subscription({
+            userId: user.id,
+            status: event.subscriptionStatus,
+            creationDate: now,
+            lastUpdate: now,
+            expirationDate: event.expirationTimestamp,
+            store: event.store == "APP_STORE"
+                ? Stores.APPLE_STORE
+                : Stores.PLAY_STORE,
+            productId: event.product_id,
+        }, subscriptionRepository);
+    }
+    return new Subscription({
+        userId: user.id,
+        status: event.subscriptionStatus,
+        creationDate: subscription.creationDate,
+        lastUpdate: now,
+        expirationDate: event.expirationTimestamp,
+        store: event.store == "APP_STORE"
+            ? Stores.APPLE_STORE
+            : Stores.PLAY_STORE,
+        productId: event.product_id,
+      }, subscriptionRepository);
+  }
+
+  static fromEntity(
+    entity: SubscriptionEntity,
+    subscriptionRepository: SubscriptionsRepository,
+  ): Subscription {
+    if (!entity.id) {
+        throw new Error("Subscription entity must have an id");
+    }
+    return new Subscription({
+      userId: entity.id!,
+      status: entity.status,
+      creationDate: entity.creation_date,
+      lastUpdate: entity.last_activity,
+      expirationDate: entity.expiration_date,
+      store: entity.store,
+      productId: entity.product_id,
+    }, subscriptionRepository);
+  }
+
+  static async fromUserId({
+    userId,
+    subscriptionRepository,
+  }: {
+    userId: string;
+    subscriptionRepository: SubscriptionsRepository;
+  }): Promise<Subscription | null> {
+    const userAuth = await admin.auth().getUser(userId);
+    const isEarlyBird = userAuth.customClaims &&
+      userAuth.customClaims.EARLY_BIRD;
+    if (isEarlyBird) {
+      return new Subscription({
+        userId,
+        status: SubscriptionStatus.ACTIVE,
+        creationDate: admin.firestore.Timestamp.now(),
+        lastUpdate: admin.firestore.Timestamp.now(),
+        store: Stores.EARLY_BIRD,
+        productId: "early_bird",
+      }, subscriptionRepository);
+    }
+    return subscriptionRepository.getFromUserId(userId);
+  }
+
+  async save(): Promise<void> {
+    await this.subscriptionRepository.save(this);
+  }
+
+  get active(): boolean {
+    if (this.status == SubscriptionStatus.ACTIVE) {
+      return true;
+    }
+    if (this.status == SubscriptionStatus.LIFETIME) {
+      return true;
+    }
+    if (!this.expirationDate) {
+      return false;
+    }
+    const now = new Date();
+    const expirationDate = this.expirationDate?.toDate();
+    if (expirationDate && expirationDate > now) {
+      return true;
+    }
+    return false;
+  }
+
+  get duration(): SubscriptionDuration {
+    if (!this.expirationDate) {
+      return subscriptionDuration.LIFETIME;
+    }
+    if (this.productId.includes("weekly")) {
+      return subscriptionDuration.WEEKLY;
+    } else if (this.productId.includes("monthly")) {
+      return subscriptionDuration.MONTHLY;
+    } else if (this.productId.includes("annual")) {
+      return subscriptionDuration.YEARLY;
+    }
+    if (this.productId.includes("lifetime")) {
+      return subscriptionDuration.LIFETIME;
+    }
+    return subscriptionDuration.LIFETIME;
+  }
+}

package/templates/firebase/functions/src/subscriptions/subscriptions_functions.ts

@@ -0,0 +1,135 @@
+import { error } from "firebase-functions/logger";
+import { https } from "firebase-functions";
+import {onRequest} from "firebase-functions/v2/https";
+import * as express from "express";
+import { Subscription } from "./models/subscriptions";
+import {
+  subscriptionsRepository,
+  userDevicesRepository,
+  usersRepository,
+} from "../core/data/repositories/repositories";
+import {PeriodTypes, RevenueCatEvent} from "./models/revenuecat_events";
+import {defineSecret} from "firebase-functions/params";
+import {SubscriptionStatus} from "./models/subscription_status";
+import {createBaseEventParams, MetaAdsApi} from "../core/api/meta_ads_api";
+
+
+// firebase functions:config:set revenuecat.token=""
+const revenuecatToken = defineSecret("REVENUECAT_WEBHOOK_KEY");
+const metaAccessToken = defineSecret("META_ACCESS_TOKEN");
+const metaDatasetId = defineSecret("META_DATASET_ID");
+
+async function sendMetaEventsForSubscription(
+  event: RevenueCatEvent,
+  subscription: Subscription,
+): Promise<void> {
+  if (!metaAccessToken.value() || !metaDatasetId.value()) return;
+  try {
+    const user = await usersRepository.getFromId(event.app_user_id);
+    if (!user) {
+      console.log("[meta-ads] user not found, skipping");
+      return;
+    }
+
+    const userDevices = await userDevicesRepository.getDevices([event.app_user_id]);
+    if (userDevices.length === 0) {
+      console.log("[meta-ads] no device found, skipping");
+      return;
+    }
+
+    // Prefer device with anonymousFbId when possible.
+    const selectedDevice = userDevices.find(
+      (device) => Boolean(device.extra_data?.anonymousFbId),
+    ) ?? userDevices[0];
+
+    const params = createBaseEventParams(user, selectedDevice);
+    if (!params.anonymousFbId) {
+      console.log("[meta-ads] device has no anonymousFbId, skipping");
+      return;
+    }
+
+    const api = new MetaAdsApi();
+    if (event.type === "INITIAL_PURCHASE" && event.period_type === PeriodTypes.TRIAL) {
+      await api.sendStartTrialEvent({
+        ...params,
+        trialValue: event.price_in_purchased_currency ?? undefined,
+        currency: event.currency ?? undefined,
+      });
+      return;
+    }
+
+    if (event.subscriptionStatus === SubscriptionStatus.LIFETIME) {
+      await api.sendLifetimeEvent({
+        ...params,
+        lifetimeValue: event.price_in_purchased_currency ?? undefined,
+        currency: event.currency ?? undefined,
+      });
+      return;
+    }
+
+    if (event.isInitialPurchase || event.type === "RENEWAL") {
+      if (event.price_in_purchased_currency == null || event.currency == null) {
+        console.log("[meta-ads] missing currency/value for subscription event");
+        return;
+      }
+      await api.sendSubscriptionEvent({
+        ...params,
+        subscriptionValue: event.price_in_purchased_currency,
+        currency: event.currency,
+      });
+    }
+  } catch (e) {
+    // Meta conversion should never break webhook processing.
+    console.log(`[meta-ads] skipped: ${e}`);
+  }
+}
+
+export const onRcPremiumUpdate = onRequest({cors: true, secrets: [revenuecatToken, metaAccessToken, metaDatasetId]}, async (
+  req: https.Request, 
+  res: express.Response,
+) => {
+    console.log("[onPremiumUpdate]");
+    const authorization = req.header("Authorization");
+    if (!authorization) {
+      console.log("Unauthorized - no token provided");
+      res.status(401).send("Unauthorized - no token provided");
+      return;
+    }
+    if (authorization !== revenuecatToken.value()) {
+      console.log("Unauthorized - invalid token");
+      res.status(401).send("Unauthorized - invalid token");
+      return;
+    }
+    const event = RevenueCatEvent.fromData({ ...req.body.event });
+    console.log("event type", event.type);
+    console.log("product id", event.product_id);
+    if (event.shouldIgnore) {
+      console.log("ignored event");
+      res.status(200).send("ignored event");
+      return;
+    }
+    try {
+      const subscription = await Subscription.fromRevenueCat({
+        event,
+        userRepository: usersRepository,
+        subscriptionRepository: subscriptionsRepository,
+      });
+      await subscription.save();
+      await sendMetaEventsForSubscription(event, subscription);
+  
+      if (event.isInitialPurchase || event.type === "RENEWAL") {
+        //-- new subscription or renewal
+      } else if (
+        event.type === "INITIAL_PURCHASE" &&
+        event.period_type === PeriodTypes.TRIAL
+      ) {
+        //-- trial started
+      } else if (event.subscriptionStatus === SubscriptionStatus.LIFETIME) {
+        //-- 
+      }
+      res.status(200).send("ok");
+    } catch (e) {
+      error(e);
+      res.status(500).send(e instanceof Error ? e.message : String(e));
+    }
+  });

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

@@ -0,0 +1,35 @@
+import { Logger } from "../core/logger/logger";
+import {usersRepository} from "../core/data/repositories/repositories";
+import {notificationsApi} from "../notifications/notifications_api";
+import {SystemNotificationParams} from "../notifications/models/notification";
+import {onDocumentCreated} from "firebase-functions/v2/firestore";
+
+export const onNewSubscription = onDocumentCreated(
+  "subscriptions/{userId}",
+  async (event) => {
+    if (!event.data) {
+      return Promise.resolve();
+    }
+    const userId = event.params.userId;
+    const logger = new Logger("onNewSubscription");
+    
+    try {
+      logger.info(`New subscription for user ${userId}`);
+      const user = await usersRepository.getFromId(userId);
+      if (!user) {
+        logger.error(`User ${userId} not found`);
+        return;
+      }
+      await notificationsApi.notify(
+        [userId],
+        <SystemNotificationParams> {
+          title: "Subscription saved",
+          body: "Thank you",
+        },
+      );
+    } catch (error) {
+      logger.error(
+        `Error processing subscription for user ${userId} : ${error}`,
+      );
+    }
+  });

package/templates/firebase/functions/src/test/core/data/entities/entity_utils.spec.ts

@@ -0,0 +1,44 @@
+import {cleanData, cleanEntityId, cleanStringForCompare} from "../../../../core/data/entities/entity_utils";
+
+
+describe("cleanStringForCompare", () => {
+  it("should remove all multiple spaces, accents and -,_", () => {
+    expect(cleanStringForCompare("LANFEUST DES ÉTOILES")).toBe("lanfeust des etoiles");
+    expect(cleanStringForCompare("Lanfeust des étoiles")).toBe("lanfeust des etoiles");
+    expect(cleanStringForCompare("ùnià as THE fear-of-ça")).toBe("unia as the fear of ca");
+  });
+});
+
+describe("cleanData", () => {
+  it("should remove object null or undefined properties", () => {
+    const input = {a: null, b: undefined, c: "c"};
+    const output = cleanData(input);
+    expect(output).toEqual({c: "c"});
+  });
+
+  it("should not change input", () => {
+    const input = {a: null, b: undefined, c: "c"};
+    const output = cleanData(input);
+    expect(output).not.toEqual(input);
+  });
+});
+
+describe("cleanEntityId", () => {
+  it("should remove object null or undefined properties", () => {
+    const input = {a: null, b: undefined, c: "c"};
+    const output = cleanEntityId(input);
+    expect(output).toEqual({c: "c"});
+  });
+
+  it("should remove object id", () => {
+    const input = {id: "dsqdd", b: undefined, c: "c"};
+    const output = cleanEntityId(input);
+    expect(output).toEqual({c: "c"});
+  });
+
+  it("should not change input", () => {
+    const input = {a: null, b: undefined, c: "c"};
+    const output = cleanEntityId(input);
+    expect(output).not.toEqual(input);
+  });
+});

package/templates/firebase/functions/tsconfig.dev.json

@@ -0,0 +1,5 @@
+{
+  "include": [
+    ".eslintrc.js"
+  ]
+}

package/templates/firebase/functions/tsconfig.json

@@ -0,0 +1,18 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "noImplicitReturns": true,
+        "noUnusedLocals": true,
+        "outDir": "lib",
+        "sourceMap": true,
+        "strict": true,
+        "target": "es2017",
+        "skipLibCheck": true,
+        "esModuleInterop": true
+    },
+    "compileOnSave": true,
+    "include": [
+        "src",
+        "jest.config.js"
+    ]
+}

package/templates/firebase/home_widget_config.json

@@ -0,0 +1,30 @@
+{
+  "widgets": [
+    {
+      "name": "MyWidget",
+      "description": "Sample home widget generated by kasy",
+      "metadata": {
+        "title": {
+          "type": "string",
+          "defaultValue": "Hello"
+        },
+        "counter": {
+          "type": "number",
+          "defaultValue": "0"
+        }
+      },
+      "isLockScreenWidget": false,
+      "iosSizes": [
+        "systemSmall",
+        "systemMedium",
+        "systemLarge"
+      ],
+      "androidSize": {
+        "minWidth": 180,
+        "minHeight": 180,
+        "targetCellWidth": 2,
+        "targetCellHeight": 2
+      }
+    }
+  ]
+}

package/templates/firebase/ios/Flutter/AppFrameworkInfo.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>App</string>
+  <key>CFBundleIdentifier</key>
+  <string>io.flutter.flutter.app</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>App</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>1.0</string>
+</dict>
+</plist>

package/templates/firebase/ios/Flutter/Debug.xcconfig

@@ -0,0 +1,2 @@
+#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"
+#include "Generated.xcconfig"

package/templates/firebase/ios/Flutter/Profile.xcconfig

@@ -0,0 +1,2 @@
+#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"
+#include "Generated.xcconfig"

package/templates/firebase/ios/Flutter/Release.xcconfig

@@ -0,0 +1,2 @@
+#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"
+#include "Generated.xcconfig"

package/templates/firebase/ios/HomeWidgetExtension/HomeWidgetBundle.swift

@@ -0,0 +1,13 @@
+import WidgetKit
+import SwiftUI
+
+@main
+struct HomeWidgetBundle: WidgetBundle {
+    var body: some Widget {
+        // the list of widgets - generated from KasyCLI
+
+        MyWidgetWidget()
+
+    }
+}
+