feature(shopify): auto assign shopify customers to a default shopify plan with a 50 messages per month limit and send dittofeed user information on signup

Author: cdxker

server/migrations/2025-04-14-223754_create-default-shopify-plan/down.sql

@@ -0,0 +1,2 @@
+-- This file should undo anything in `up.sql`
+delete from stripe_plans where id = 'dead0000-f0ee-4000-a000-000000000000';

server/migrations/2025-04-14-223754_create-default-shopify-plan/up.sql

@@ -0,0 +1,4 @@
+-- Your SQL goes here
+INSERT into stripe_plans (id, stripe_id, chunk_count, user_count, dataset_count, message_count, amount, created_at, updated_at, name, visible, file_storage, messages_per_month) VALUES (
+    'dead0000-f0ee-4000-a000-000000000000', 'dead0000-f0ee-4000-a000-000000000000', 1147483647, 1147483647, 1147483647, 1147483647, 0, now(), now(), 'Free Shop Tier', false, 1147483647, 50
+);

server/src/handlers/auth_handler.rs

@@ -1,10 +1,15 @@
 use crate::data::models::{ApiKeyRole, Organization, RedisPool, UserRole};
 use crate::get_env;
-use crate::operators::dittofeed_operator::{get_user_ditto_identity, send_user_ditto_identity};
+use crate::handlers::shopify_handler::ShopifyCustomerEvent;
+use crate::operators::dittofeed_operator::{
+    get_user_ditto_identity, send_user_ditto_identity, DittoBatchRequest, DittoBatchRequestTypes,
+    DittoTrackProperties, DittoTrackRequest, DittofeedIdentifyUser, DittofeedUserTraits,
+};
 use crate::operators::invitation_operator::check_inv_valid;
 use crate::operators::organization_operator::{
     create_organization_api_key_query, get_org_from_id_query, get_user_org_count,
 };
+use crate::operators::payment_operator::create_flat_subscription_query;
 use crate::operators::user_operator::{
     add_user_to_organization, associate_user_to_oidc_subject_query, create_user_query,
     get_option_user_by_email_query, get_user_by_oidc_subject_query,
@@ -728,7 +733,74 @@ pub async fn create_api_only_user(
 
     let (user, user_orgs, orgs) = match option_user {
         Some(user) => get_user_by_id_query(&user.id, pool.clone()).await?,
-        None => create_account(user_email, user_name, None, None, None, pool.clone()).await?,
+        None => {
+            let (user, user_orgs, orgs) = create_account(
+                user_email.clone(),
+                user_name.clone(),
+                None,
+                None,
+                None,
+                pool.clone(),
+            )
+            .await?;
+
+            // Associate orgs.0 with api_only_price
+            let organization = orgs
+                .first()
+                .ok_or(ServiceError::BadRequest(
+                    "Failed to create organization for api only user; please try again".to_string(),
+                ))?
+                .clone();
+
+            create_flat_subscription_query(
+                "shopify_free_plan".to_string(),
+                uuid::Uuid::parse_str("dead0000-f0ee-4000-a000-000000000000")
+                    .expect("hardcoded should be valid uuid"),
+                organization.id,
+                None,
+                pool.clone(),
+            )
+            .await?;
+
+            // Send user ditto identity with shopify tag
+            let ditto_batch_request = vec![
+                DittoBatchRequestTypes::Identify(DittofeedIdentifyUser {
+                    r#type: Some("identify".to_string()),
+                    message_id: uuid::Uuid::new_v4(),
+                    user_id: user.id,
+                    traits: DittofeedUserTraits {
+                        email: user.email.clone(),
+                        name: user.name.clone(),
+                        created_at: user.created_at,
+                        organization_count: 1,
+                        dataset_count: 1,
+                    },
+                }),
+                DittoBatchRequestTypes::Track(DittoTrackRequest {
+                    r#type: Some("track".to_string()),
+                    message_id: format!(
+                        "{}-{}-{}",
+                        user_email.clone(),
+                        user.id,
+                        "shopify_installed"
+                    ),
+                    event: "shopify_installed".to_string(),
+                    properties: DittoTrackProperties::DittoShopifyEvent(ShopifyCustomerEvent {
+                        organization_id: organization.id,
+                        store_name: user_name.clone(),
+                        event_type: "shopify_installed".to_string(),
+                    }),
+                    user_id: user.id,
+                }),
+            ];
+
+            let _ = send_user_ditto_identity(DittoBatchRequest {
+                batch: ditto_batch_request,
+            })
+            .await;
+
+            (user, user_orgs, orgs)
+        }
     };
 
     let organization = orgs

server/src/handlers/payment_handler.rs

@@ -9,9 +9,9 @@ use crate::{
             get_org_from_id_query, get_org_id_from_subscription_id_query, get_org_usage_by_id_query,
         },
         payment_operator::{
-            cancel_stripe_subscription, create_invoice_query, create_stripe_payment_link,
-            create_stripe_plan_query, create_stripe_setup_checkout_session,
-            create_stripe_subscription_query, create_usage_based_stripe_payment_link,
+            cancel_stripe_subscription, create_flat_subscription_query, create_invoice_query,
+            create_stripe_payment_link, create_stripe_plan_query,
+            create_stripe_setup_checkout_session, create_usage_based_stripe_payment_link,
             create_usage_stripe_subscription_query, delete_subscription_by_id_query,
             delete_usage_subscription_by_id_query, get_all_plans_query, get_all_usage_plans_query,
             get_bill_from_range, get_invoices_for_org_query,
@@ -201,7 +201,7 @@ pub async fn webhook(
                                 )
                                 .await;
 
-                                create_stripe_subscription_query(
+                                create_flat_subscription_query(
                                     subscription_stripe_id,
                                     plan_id,
                                     organization_id,
@@ -477,7 +477,7 @@ pub async fn update_subscription_plan(
                 }
                 TrieveSubscription::UsageBased(_) => {
                     // Old was usage based, create a new entry for flat
-                    create_stripe_subscription_query(
+                    create_flat_subscription_query(
                         current_trieve_subscription.stripe_subscription_id(),
                         flat_plan.id,
                         current_trieve_subscription.organization_id(),
@@ -765,7 +765,7 @@ pub async fn handle_shopify_plan_change(
         return Err(ServiceError::BadRequest("Invalid session token".to_string()).into());
     }
 
-    let organization_plan =
+    let organization_sub =
         get_option_subscription_by_organization_id_query(payload.organization_id, pool.clone())
             .await
             .map_err(|e| ServiceError::BadRequest(e.to_string()))?;
@@ -774,28 +774,28 @@ pub async fn handle_shopify_plan_change(
         .await
         .map_err(|e| ServiceError::BadRequest(e.to_string()))?;
 
-    if let Some(organization_plan) = organization_plan {
-        if organization_plan.stripe_id == payload.idempotency_key {
+    if let Some(organization_sub) = organization_sub {
+        if organization_sub.stripe_id == payload.idempotency_key {
             return Ok(HttpResponse::NoContent().finish());
         }
 
-        if organization_plan.plan_id == plan.id
+        if organization_sub.plan_id == plan.id
             && payload.shopify_plan.status.to_lowercase() == "active"
         {
             return Ok(HttpResponse::NoContent().finish());
-        } else if organization_plan.plan_id == plan.id
+        } else if organization_sub.plan_id == plan.id
             && payload.shopify_plan.status.to_lowercase() != "active"
         {
             set_stripe_subscription_current_period_end(
-                organization_plan.stripe_id,
+                organization_sub.stripe_id,
                 chrono::Utc::now().naive_utc(),
                 pool,
             )
             .await?;
-        } else if organization_plan.plan_id != plan.id
+        } else if organization_sub.plan_id != plan.id
             && payload.shopify_plan.status.to_lowercase() == "active"
         {
-            create_stripe_subscription_query(
+            create_flat_subscription_query(
                 payload.idempotency_key.clone(),
                 plan.id,
                 payload.organization_id,
@@ -805,7 +805,7 @@ pub async fn handle_shopify_plan_change(
             .await?;
         }
     } else if payload.shopify_plan.status.to_lowercase() == "active" {
-        create_stripe_subscription_query(
+        create_flat_subscription_query(
             payload.idempotency_key.clone(),
             plan.id,
             payload.organization_id,

server/src/operators/payment_operator.rs

@@ -175,7 +175,7 @@ pub async fn update_static_stripe_meters(
     Ok(static_events)
 }
 
-pub async fn create_stripe_subscription_query(
+pub async fn create_flat_subscription_query(
     stripe_id: String,
     plan_id: uuid::Uuid,
     organization_id: uuid::Uuid,