@bonifaceebuka/core-backend 1.0.0

package/dist/database/seeds/CommunityDataSeeder.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommunityDataSeeder = CommunityDataSeeder;
+const TopicRepository_1 = require("../../repositories/TopicRepository");
+async function CommunityDataSeeder() {
+    const topicRepository = new TopicRepository_1.TopicRepository();
+    const community_topics = [
+        {
+            name: "Support"
+        },
+        {
+            name: "Therapy"
+        },
+        {
+            name: "Advocacy"
+        },
+        {
+            name: "Learning"
+        },
+        {
+            name: "Resources"
+        }, {
+            name: "Wellness"
+        }, {
+            name: "Learning"
+        }, {
+            name: "Daily living & Routines"
+        },
+        {
+            name: 'Events & meetups'
+        },
+    ];
+    for (const community_topic of community_topics) {
+        const { name } = community_topic;
+        const exists = await topicRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await topicRepository.create({
+                name,
+            });
+            console.log(`✅ Community topic "${community_topic.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Community topic "${community_topic.name}" already exists, skipping`);
+        }
+    }
+}

package/dist/database/seeds/EventDataSeeder.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventDataSeeder = EventDataSeeder;
+const EventTypeRepository_1 = require("../../repositories/EventTypeRepository");
+async function EventDataSeeder() {
+    const eventTypeRepository = new EventTypeRepository_1.EventTypeRepository();
+    const event_types = [
+        {
+            name: "Playdate"
+        },
+        {
+            name: "Sensory Play"
+        },
+        {
+            name: "Community Meetup"
+        },
+        {
+            name: "Caregivers Meetup"
+        },
+        {
+            name: "Experience Sharing Session"
+        }, {
+            name: "Emotional Support Meetup"
+        }, {
+            name: "Support Circle"
+        }, {
+            name: "Weekend Play Meetup"
+        },
+        {
+            name: 'Indoor Play Session'
+        },
+        {
+            name: 'Parenting Tips Session'
+        },
+        {
+            name: 'Family Hangout'
+        }
+    ];
+    for (const event_type of event_types) {
+        const { name } = event_type;
+        const exists = await eventTypeRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await eventTypeRepository.create({
+                name,
+            });
+            console.log(`✅ Event type "${event_type.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Event type "${event_type.name}" already exists, skipping`);
+        }
+    }
+}

package/dist/database/seeds/FeatureSeeder.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureSeeder = FeatureSeeder;
+const PlanRepository_1 = require("../../repositories/PlanRepository");
+const PlanFeatureRepository_1 = require("../../repositories/PlanFeatureRepository");
+const FeatureRepository_1 = require("../../repositories/FeatureRepository");
+async function FeatureSeeder() {
+    const featureRepository = new FeatureRepository_1.FeatureRepository();
+    const planRepository = new PlanRepository_1.PlanRepository();
+    const planFeatureRepository = new PlanFeatureRepository_1.PlanFeatureRepository();
+    const free_plan_features = [
+        {
+            name: "Access to Only basic things",
+            description: "Access to Only basic things",
+            code: "access_to_basic_things",
+        },
+    ];
+    for (const feature of free_plan_features) {
+        let free_plan_feature = await featureRepository.basicFindOneByConditions({
+            code: feature.code
+        });
+        if (!free_plan_feature) {
+            free_plan_feature = await featureRepository.create(feature);
+            console.log(`✅ Feature "${feature.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Feature "${feature.name}" already exists, skipping`);
+        }
+        // Free plan
+        const freePlan = await planRepository.basicFindOneByConditions({
+            name: "Free",
+        });
+        if (freePlan) {
+            // Check if feature is already in plan
+            const planFeature = await planFeatureRepository.basicFindOneByConditions({
+                plan_id: freePlan.id,
+                feature_id: free_plan_feature.id,
+            });
+            if (planFeature) {
+                console.log(`⚡ Feature "${feature.name}" already in Free plan, skipping`);
+            }
+            else {
+                await planFeatureRepository.create({
+                    plan: freePlan,
+                    feature: free_plan_feature,
+                });
+                console.log(`✅ Feature "${feature.name}" seeded`);
+            }
+        }
+    }
+    const care_circle_plan_features = [
+        {
+            name: "Everything in Free",
+            description: "Everything in Free",
+            code: "everything_in_free",
+        }
+    ];
+    for (const feature of care_circle_plan_features) {
+        let care_circle_plan_feature = await featureRepository.basicFindOneByConditions({
+            code: feature.code
+        });
+        if (!care_circle_plan_feature) {
+            care_circle_plan_feature = await featureRepository.create(feature);
+            console.log(`✅ Feature "${feature.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Feature "${feature.name}" already exists, skipping`);
+        }
+        // Free plan
+        const plan = await planRepository.basicFindOneByConditions({
+            name: "Care Circle Plan",
+        });
+        if (plan) {
+            // Check if feature is already in plan
+            const planFeature = await planFeatureRepository.basicFindOneByConditions({
+                plan_id: plan.id,
+                feature_id: care_circle_plan_feature.id,
+            });
+            if (planFeature) {
+                console.log(`⚡ Feature "${feature.name}" already in Care Circle plan, skipping`);
+            }
+            else {
+                await planFeatureRepository.create({
+                    plan: plan,
+                    feature: care_circle_plan_feature,
+                });
+                console.log(`✅ Feature "${feature.name}" seeded`);
+            }
+        }
+    }
+    const impact_pro_plan_features = [
+        {
+            name: "Everything in Free + Care Circle plan",
+            description: "Everything in Free + Care Circle plan",
+            code: "everything_in_free_plus_care_circle",
+        },
+    ];
+    for (const feature of impact_pro_plan_features) {
+        let impact_pro_plan_feature = await featureRepository.basicFindOneByConditions({
+            code: feature.code
+        });
+        if (!impact_pro_plan_feature) {
+            impact_pro_plan_feature = await featureRepository.create(feature);
+            console.log(`✅ Feature "${feature.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Feature "${feature.name}" already exists, skipping`);
+        }
+        // Free plan
+        const plan = await planRepository.basicFindOneByConditions({
+            name: "Impact pro plan",
+        });
+        if (plan) {
+            // Check if feature is already in plan
+            const planFeature = await planFeatureRepository.basicFindOneByConditions({
+                plan_id: plan.id,
+                feature_id: impact_pro_plan_feature.id,
+            });
+            if (planFeature) {
+                console.log(`⚡ Feature "${feature.name}" already in Impact pro plan, skipping`);
+            }
+            else {
+                await planFeatureRepository.create({
+                    plan: plan,
+                    feature: impact_pro_plan_feature,
+                });
+                console.log(`✅ Feature "${feature.name}" seeded`);
+            }
+        }
+    }
+}

package/dist/database/seeds/MarketplaceDataSeeder.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarketplaceDataSeeder = MarketplaceDataSeeder;
+exports.BusinessIdCategoryDataSeeder = BusinessIdCategoryDataSeeder;
+exports.BusinessCategoryDataSeeder = BusinessCategoryDataSeeder;
+const BusinessIdCategoryRepository_1 = require("../../repositories/BusinessIdCategoryRepository");
+const BusinessCategoryRepository_1 = require("../../repositories/BusinessCategoryRepository");
+const CategoryRepository_1 = require("../../repositories/CategoryRepository");
+async function MarketplaceDataSeeder() {
+    const categoryRepository = new CategoryRepository_1.CategoryRepository();
+    const categories = [
+        {
+            name: "Medicine"
+        },
+        {
+            name: "Food"
+        },
+        {
+            name: "MsardTheis chect Supplement"
+        }
+    ];
+    for (const category of categories) {
+        const { name } = category;
+        const exists = await categoryRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await categoryRepository.create({
+                name,
+            });
+            console.log(`✅ Product category "${category.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Product category "${category.name}" already exists, skipping`);
+        }
+    }
+}
+async function BusinessIdCategoryDataSeeder() {
+    const businessIdCategoryRepository = new BusinessIdCategoryRepository_1.BusinessIdCategoryRepository();
+    const categories = [
+        {
+            name: "Driver's license"
+        },
+        {
+            name: "National ID"
+        },
+        {
+            name: "Int'l Passport"
+        }
+    ];
+    for (const businessCategory of categories) {
+        const { name } = businessCategory;
+        const exists = await businessIdCategoryRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await businessIdCategoryRepository.create({
+                name,
+            });
+            console.log(`✅ Business ID category "${name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Business ID category "${name}" already exists, skipping`);
+        }
+    }
+}
+async function BusinessCategoryDataSeeder() {
+    const businessCategoryRepository = new BusinessCategoryRepository_1.BusinessCategoryRepository();
+    const categories = [
+        {
+            name: "Fintech"
+        },
+        {
+            name: "Food stuff"
+        },
+        {
+            name: "Education"
+        }
+    ];
+    for (const businessCategory of categories) {
+        const { name } = businessCategory;
+        const exists = await businessCategoryRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await businessCategoryRepository.create({
+                name,
+            });
+            console.log(`✅ Business category "${businessCategory.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Business category "${businessCategory.name}" already exists, skipping`);
+        }
+    }
+}

package/dist/database/seeds/PlanSeeder.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanSeeder = PlanSeeder;
+const StripeService_1 = __importDefault(require("../../services/StripeService"));
+const PlanRepository_1 = require("../../repositories/PlanRepository");
+async function PlanSeeder() {
+    const planRepository = new PlanRepository_1.PlanRepository();
+    const stripeService = new StripeService_1.default();
+    const plans = [
+        {
+            name: "Free",
+            description: "Get started with basic features",
+            monthly: 0,
+            yearly: 0,
+            stripe_monthly_plan_code: null,
+            stripe_yearly_plan_code: null,
+            icon: "Sparkles",
+            discount: 0,
+        },
+        {
+            name: "Care Circle Plan",
+            description: "Basic things you need",
+            yearly: 17.99,
+            stripe_monthly_plan_code: null,
+            stripe_yearly_plan_code: null,
+            icon: "Crown",
+            monthly: 7.99,
+            discount: 0,
+        },
+        {
+            name: "Impact pro plan",
+            description: "For serious users",
+            monthly: 10.88,
+            yearly: 200.88,
+            discount: 0,
+            stripe_monthly_plan_code: null,
+            stripe_yearly_plan_code: null,
+            icon: "Zap",
+        },
+    ];
+    for (const plan of plans) {
+        const { name, description, monthly, yearly, discount } = plan;
+        const exists = await planRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            if (monthly > 0 && yearly > 0) {
+                const stripeMonthlyPlan = await stripeService.createStripePlan(name, monthly, "month");
+                const stripeYearlyPlan = await stripeService.createStripePlan(name, yearly, "year");
+                await planRepository.create({
+                    name,
+                    description,
+                    monthly: monthly.toString(),
+                    yearly: yearly.toString(),
+                    stripe_monthly_plan_code: stripeMonthlyPlan?.data?.plan_code,
+                    stripe_yearly_plan_code: stripeYearlyPlan?.data?.plan_code,
+                    discount: discount.toString(),
+                });
+            }
+            else {
+                await planRepository.create({
+                    name,
+                    description,
+                    monthly: monthly.toString(),
+                    yearly: yearly.toString(),
+                    discount: discount.toString()
+                });
+            }
+            console.log(`✅ Plan "${plan.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Plan "${plan.name}" already exists, skipping`);
+        }
+    }
+}

package/dist/database/seeds/UserProfileDataSeeder.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserProfileDataSeeder = UserProfileDataSeeder;
+const SpeechRepository_1 = require("../../repositories/SpeechRepository");
+const DiagnosisLevelRepository_1 = require("../../repositories/DiagnosisLevelRepository");
+const InterestRepository_1 = require("../../repositories/InterestRepository");
+const ChallengeRepository_1 = require("../../repositories/ChallengeRepository");
+const EducationRepository_1 = require("../../repositories/EducationRepository");
+const GoalRepository_1 = require("../../repositories/GoalRepository");
+async function UserProfileDataSeeder() {
+    const diagnosisLevelRepository = new DiagnosisLevelRepository_1.DiagnosisLevelRepository();
+    const interestRepository = new InterestRepository_1.InterestRepository();
+    const speechRepository = new SpeechRepository_1.SpeechRepository();
+    const challengeRepository = new ChallengeRepository_1.ChallengeRepository();
+    const educationRepository = new EducationRepository_1.EducationRepository();
+    const goalRepository = new GoalRepository_1.GoalRepository();
+    const diagnosis_levels = [
+        {
+            name: "Level 1 - Low support needs"
+        },
+        {
+            name: "Level 2 - Moderate support needs"
+        },
+        {
+            name: "Level 3 - High support needs"
+        },
+    ];
+    const interests = [
+        {
+            name: "Peer support"
+        },
+        {
+            name: "Playdates"
+        },
+        {
+            name: "Coffee chats"
+        },
+        {
+            name: "Volunteering"
+        },
+    ];
+    const speeches = [
+        {
+            name: "Non-speaking"
+        },
+        {
+            name: "Semi-verbal"
+        },
+        {
+            name: "Verbal"
+        },
+        {
+            name: "Conversational"
+        },
+    ];
+    const challenges = [
+        {
+            name: "Aggression"
+        },
+        {
+            name: "Hyperactivity"
+        },
+        {
+            name: "Sensory"
+        },
+        {
+            name: "Picky Eater"
+        },
+        {
+            name: "Insomnia"
+        }, {
+            name: "Eloping"
+        }, {
+            name: "Executive Function"
+        }, {
+            name: "Not Toilet-trained"
+        },
+    ];
+    const education_levels = [
+        {
+            name: "ABA program"
+        },
+        {
+            name: "General education"
+        },
+        {
+            name: "High school"
+        },
+        {
+            name: "Graduate"
+        },
+        {
+            name: "College"
+        }, {
+            name: "Eloping"
+        }, {
+            name: "Work study program"
+        }, {
+            name: "Not school-ready"
+        },
+    ];
+    const goals = [
+        {
+            name: "Join community"
+        },
+        {
+            name: "Help my child"
+        },
+        {
+            name: "Visit marketplace"
+        },
+        {
+            name: "Learn more about Autism"
+        },
+        {
+            name: "Access to resources"
+        }, {
+            name: "Connect with fellow cargivers"
+        }, {
+            name: "Access therapy sessions"
+        }, {
+            name: "Connect with professionals"
+        },
+    ];
+    for (const diagnosis_level of diagnosis_levels) {
+        const { name } = diagnosis_level;
+        const exists = await diagnosisLevelRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await diagnosisLevelRepository.create({
+                name,
+            });
+            console.log(`✅ Diagnosis level "${diagnosis_level.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Diagnosis level "${diagnosis_level.name}" already exists, skipping`);
+        }
+    }
+    for (const interest of interests) {
+        const { name } = interest;
+        const exists = await interestRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await interestRepository.create({
+                name,
+            });
+            console.log(`✅ Diagnosis level "${interest.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Diagnosis level "${interest.name}" already exists, skipping`);
+        }
+    }
+    for (const speech of speeches) {
+        const { name } = speech;
+        const exists = await speechRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await speechRepository.create({
+                name,
+            });
+            console.log(`✅ Speech "${speech.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Speech "${speech.name}" already exists, skipping`);
+        }
+    }
+    for (const challenge of challenges) {
+        const { name } = challenge;
+        const exists = await challengeRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await challengeRepository.create({
+                name,
+            });
+            console.log(`✅ Challenge "${challenge.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Challenge "${challenge.name}" already exists, skipping`);
+        }
+    }
+    for (const education of education_levels) {
+        const { name } = education;
+        const exists = await educationRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await educationRepository.create({
+                name,
+            });
+            console.log(`✅ Education "${education.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Education "${education.name}" already exists, skipping`);
+        }
+    }
+    for (const goal of goals) {
+        const { name } = goal;
+        const exists = await goalRepository.basicFindOneByConditions({
+            name
+        });
+        if (!exists) {
+            await goalRepository.create({
+                name,
+            });
+            console.log(`✅ Goal "${goal.name}" seeded`);
+        }
+        else {
+            console.log(`⚡ Goal "${goal.name}" already exists, skipping`);
+        }
+    }
+}

package/dist/database/seeds/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const postgres_1 = require("../../common/configs/postgres");
+const MarketplaceDataSeeder_1 = require("./MarketplaceDataSeeder");
+async function runSeeders() {
+    try {
+        // Initialize the data source before running seeders
+        if (!postgres_1.dataSource.isInitialized) {
+            console.log("🔌 Initializing database connection...");
+            await postgres_1.dataSource.initialize();
+            console.log("✅ Database connected successfully");
+        }
+        // Run seeders
+        // await UserProfileDataSeeder();
+        // await EventDataSeeder();
+        // await PlanSeeder();
+        // await FeatureSeeder();
+        // await CommunityDataSeeder()
+        // await MarketplaceDataSeeder()
+        await (0, MarketplaceDataSeeder_1.BusinessCategoryDataSeeder)();
+        await (0, MarketplaceDataSeeder_1.BusinessIdCategoryDataSeeder)();
+        console.log("🌱 Seeding complete!");
+    }
+    catch (error) {
+        console.error("❌ Seeding error:", error);
+        process.exit(1);
+    }
+    finally {
+        // Close the connection after seeding
+        if (postgres_1.dataSource.isInitialized) {
+            await postgres_1.dataSource.destroy();
+            console.log("🔒 Database connection closed");
+        }
+    }
+}
+runSeeders().catch((err) => {
+    console.error("❌ Seeding error:", err);
+    process.exit(1);
+});

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./models";
+export * from "./common/configs";
+export * from "./common/constants/messages";
+export * from "./common/dtos/Paginator";
+export * from "./common/configs/postgres";
+export * from "./common/enums";
+export * from "./common/types";
+export * from "./common/utils";
+export * from "./models";
+export * from "./common/errors/AppError";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,0BAA0B,CAAC"}