@loka-sms/core-integration-be 0.0.1

package/README.md

@@ -0,0 +1,214 @@
+# @loka-sms/core-integration-be
+
+NestJS helper package untuk backend modul Loka SMS yang perlu mengakses data Core via service-to-service auth (`X-App-ID` + `X-App-Secret`).
+
+Package ini cocok untuk **worker/background job/service sync**, bukan untuk forwarding token user.
+
+## Flow
+
+```text
+Backend Modul / Worker / Cron
+  -> Gateway:3000/api/students
+     X-App-ID: <id>
+     X-App-Secret: <secret>
+     X-School-ID: <school-id>
+  -> Gateway forward ke be-loka-core:3002/api/v1/students
+  -> Core ServiceAuthGuard validasi credentials
+```
+
+Semua request tetap lewat Gateway, bukan langsung ke Core.
+
+## Install
+
+```bash
+npm install @loka-sms/core-integration-be
+```
+
+## Environment Variable
+
+| Variabel | Wajib | Fallback | Keterangan |
+|---|---|---|---|
+| `CORE_SERVICE_URL` | ✅ | — | Base URL Gateway, contoh: `http://localhost:3000/api` |
+| `CORE_APP_ID` | ✅ | `APP_ID` | Application ID yang terdaftar di Core |
+| `CORE_APP_SECRET` | ✅ | `APP_SECRET` | Application secret (plain, bukan bcrypt) |
+
+Contoh `.env`:
+
+```env
+CORE_SERVICE_URL=http://localhost:3000/api
+CORE_APP_ID=erapor-app
+CORE_APP_SECRET=erapor-secret
+```
+
+### URL Gateway
+
+| Lingkungan | `CORE_SERVICE_URL` |
+|---|---|
+| Lokal (backend di host) | `http://localhost:3000/api` |
+| Docker compose | `http://be-loka-gateway:3000/api` |
+| Production | `<gateway-url>/api` (dari environment variable production) |
+
+> **Catatan**: Jangan tambah `/api/v1` di URL jika lewat Gateway. Gateway sudah rewrite `/api` ke `/api/v1` secara otomatis.
+
+## Setup AppModule
+
+```ts
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { CoreIntegrationModule } from '@loka-sms/core-integration-be';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    CoreIntegrationModule,
+  ],
+})
+export class AppModule {}
+```
+
+Atau dengan konfigurasi eksplisit:
+
+```ts
+CoreIntegrationModule.forRoot({
+  baseUrl: 'http://localhost:3000/api',
+  appId: 'erapor-app',
+  appSecret: 'erapor-secret',
+  timeout: 10000,
+})
+```
+
+## Cara Pakai
+
+```ts
+import { Injectable } from '@nestjs/common';
+import { CoreIntegrationService } from '@loka-sms/core-integration-be';
+
+@Injectable()
+export class RaporSyncService {
+  constructor(private readonly core: CoreIntegrationService) {}
+
+  async generate(schoolId: string) {
+    const students = await this.core.getStudents(schoolId, { status: 'active' });
+    const classes = await this.core.getClasses(schoolId);
+    return { students, classes };
+  }
+}
+```
+
+Package selalu mengirim `X-App-ID`, `X-App-Secret`, dan `X-School-ID`. Tidak perlu panggil method khusus untuk set auth.
+
+## Method Tersedia
+
+| Method | Core Endpoint via Gateway |
+|---|---|
+| `getStudents(schoolId, params)` | `GET /api/students` |
+| `getStudentsByClass(classId, schoolId)` | `GET /api/students?class_id=...&status=active` |
+| `getStudent(studentId, schoolId)` | `GET /api/students/:id` |
+| `findStudentByEmail(email, schoolId)` | `GET /api/students?q=...&limit=1` |
+| `getParentChildrenByUserId(parentUserId, schoolId)` | `GET /api/parents/by-user/:id/children` |
+| `getParentChildIdsByUserId(parentUserId, schoolId)` | `GET /api/parents/by-user/:id/children` |
+| `resolveParentStudentScope(parentUserId, schoolId, requestedStudentId?)` | `GET /api/parents/by-user/:id/children` |
+| `getTeachers(schoolId)` | `GET /api/teachers` |
+| `getTeacher(teacherId, schoolId)` | `GET /api/teachers/:id` |
+| `getClasses(schoolId)` | `GET /api/classes` |
+| `getSubjects(schoolId, params)` | `GET /api/subjects` |
+| `getCurriculums(schoolId, params)` | `GET /api/curriculum` |
+| `getAcademicCalendar(schoolId, params)` | `GET /api/academic-calendar` |
+| `getRooms(schoolId, params)` | `GET /api/rooms` |
+| `getKKM(subjectId, gradeLevel, schoolId)` | `GET /api/kkm` |
+| `pushGradeToCore(schoolId, gradeData)` | `POST /api/grades/sync` |
+| `createNotification(schoolId, payload)` | `POST /api/notifications` |
+
+## Generic Request
+
+Kalau method wrapper belum tersedia:
+
+```ts
+const data = await this.core.get('teaching-schedule', schoolId, {
+  params: { class_id: classId },
+});
+
+await this.core.post('notifications', schoolId, {
+  user_id: 'user_xxx',
+  type: 'rapor_ready',
+  title: 'Rapor siap dicek',
+  message: 'Nilai akhir sudah siap.',
+});
+```
+
+Path tidak perlu diawali `/api` atau `/api/v1`.
+
+Benar:
+```ts
+this.core.get('students', schoolId)
+```
+
+Salah:
+```ts
+this.core.get('api/students', schoolId)
+this.core.get('api/v1/students', schoolId)
+```
+
+## Data Per Modul
+
+| Modul | Ambil Dari Core | Jangan Ambil Dari Core |
+|---|---|---|
+| LMS | siswa, guru, kelas, mapel, KKM, kalender | nilai berjalan (milik LMS) |
+| E-Rapor | siswa, kelas, guru, mapel, kurikulum, KKM, semester | nilai mentah tugas/ujian; ambil nilai final dari LMS |
+| Presensi | siswa, kelas, guru, kalender, jadwal | hasil presensi operasional |
+| Keuangan | siswa, orang tua, kelas | transaksi, invoice, pembayaran |
+| PPDB | referensi sekolah | data pendaftar sebelum resmi jadi siswa |
+| HRIS | guru, staff, struktur sekolah | payroll, cuti, KPI internal |
+
+## Prasyarat Core
+
+Setiap `APP_ID` harus terdaftar di tabel `loka_sms.applications` dengan secret di-hash bcrypt.
+
+Contoh registrasi:
+
+```sql
+INSERT INTO loka_sms.applications (app_id, app_secret, name, service_url, status)
+VALUES ('erapor-app', '<bcrypt-hash-dari-erapor-secret>', 'E-Rapor Service', 'http://erapor:3012', 'active');
+```
+
+Endpoint Core yang akan dipanggil juga harus memiliki decorator `@AllowServiceAuth()`. Sebagian besar endpoint sudah.
+
+## Troubleshooting
+
+### Error: CoreIntegrationModule requires baseUrl or CORE_SERVICE_URL
+
+Set env:
+```env
+CORE_SERVICE_URL=http://localhost:3000/api
+```
+
+### Error: CoreIntegrationModule requires appId or CORE_APP_ID, APP_ID
+
+Set env:
+```env
+CORE_APP_ID=erapor-app
+CORE_APP_SECRET=erapor-secret
+```
+
+### Error 401 / 403 dari Core
+
+Cek:
+- `APP_ID` dan `APP_SECRET` sudah terdaftar di tabel `loka_sms.applications`
+- Secret di database adalah bcrypt hash
+- Endpoint Core memiliki `@AllowServiceAuth()`
+- Status aplikasi di database adalah `active`
+
+### Error 404
+
+Cek path. Jangan tambah `/api` atau `/api/v1` di method.
+
+### Data kosong
+
+Cek `schoolId` yang dikirim. Pastikan `X-School-ID` benar.
+
+## Catatan
+
+- Package ini untuk service-to-service / worker mode (tanpa user JWT).
+- Semua request lewat Gateway, bukan langsung ke Core.
+- Endpoint Core tetap melakukan validasi credentials dan permission.
+- Untuk menambah `APP_ID` baru, tim Core harus insert record di tabel `applications` dengan secret bcrypt.

package/dist/core-integration.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+import { CoreIntegrationConfig } from './types';
+export declare class CoreIntegrationModule {
+    static forRoot(config?: CoreIntegrationConfig): DynamicModule;
+}

package/dist/core-integration.module.js

@@ -0,0 +1,42 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var CoreIntegrationModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreIntegrationModule = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = require("@nestjs/axios");
+const core_integration_service_1 = require("./core-integration.service");
+const types_1 = require("./types");
+let CoreIntegrationModule = CoreIntegrationModule_1 = class CoreIntegrationModule {
+    static forRoot(config = {}) {
+        return {
+            module: CoreIntegrationModule_1,
+            imports: [
+                axios_1.HttpModule.register({
+                    timeout: config.timeout ?? 5000,
+                }),
+            ],
+            providers: [
+                { provide: types_1.CORE_INTEGRATION_OPTIONS, useValue: config },
+                core_integration_service_1.CoreIntegrationService,
+            ],
+            exports: [core_integration_service_1.CoreIntegrationService],
+        };
+    }
+};
+exports.CoreIntegrationModule = CoreIntegrationModule;
+exports.CoreIntegrationModule = CoreIntegrationModule = CoreIntegrationModule_1 = __decorate([
+    (0, common_1.Module)({
+        imports: [axios_1.HttpModule],
+        providers: [
+            { provide: types_1.CORE_INTEGRATION_OPTIONS, useValue: {} },
+            core_integration_service_1.CoreIntegrationService,
+        ],
+        exports: [core_integration_service_1.CoreIntegrationService],
+    })
+], CoreIntegrationModule);

package/dist/core-integration.service.d.ts

@@ -0,0 +1,39 @@
+import { HttpService } from '@nestjs/axios';
+import { ConfigService } from '@nestjs/config';
+import { CoreIntegrationConfig, CoreNotificationPayload, CoreRequestOptions } from './types';
+export declare class CoreIntegrationService {
+    private readonly httpService;
+    private readonly configService?;
+    private readonly options;
+    private readonly logger;
+    private readonly baseUrl;
+    private readonly appId;
+    private readonly appSecret;
+    constructor(httpService: HttpService, configService?: ConfigService | undefined, options?: CoreIntegrationConfig);
+    private resolveRequired;
+    private getHeaders;
+    private makeUrl;
+    private extractStudentId;
+    get<T = any>(path: string, schoolId?: string, options?: CoreRequestOptions): Promise<T>;
+    post<T = any>(path: string, schoolId: string | undefined, body?: unknown, options?: CoreRequestOptions): Promise<T>;
+    put<T = any>(path: string, schoolId: string | undefined, body?: unknown, options?: CoreRequestOptions): Promise<T>;
+    patch<T = any>(path: string, schoolId: string | undefined, body?: unknown, options?: CoreRequestOptions): Promise<T>;
+    delete<T = any>(path: string, schoolId?: string, options?: CoreRequestOptions): Promise<T>;
+    getParentChildrenByUserId(parentUserId: string, schoolId: string): Promise<any[]>;
+    getParentChildIdsByUserId(parentUserId: string, schoolId: string): Promise<string[]>;
+    resolveParentStudentScope(parentUserId: string, schoolId: string, requestedStudentId?: string): Promise<string[]>;
+    getStudents(schoolId: string, params?: Record<string, unknown>): Promise<any[]>;
+    getStudentsByClass(classId: string, schoolId: string): Promise<any[]>;
+    getStudent(studentId: string, schoolId: string): Promise<any>;
+    findStudentByEmail(email: string, schoolId: string): Promise<any>;
+    getTeacher(teacherId: string, schoolId: string): Promise<any>;
+    getClasses(schoolId: string): Promise<any[]>;
+    getTeachers(schoolId: string): Promise<any[]>;
+    getSubjects(schoolId: string, params?: Record<string, unknown>): Promise<any[]>;
+    getCurriculums(schoolId: string, params?: Record<string, unknown>): Promise<any[]>;
+    getAcademicCalendar(schoolId: string, params?: Record<string, unknown>): Promise<any[]>;
+    getRooms(schoolId: string, params?: Record<string, unknown>): Promise<any[]>;
+    pushGradeToCore(schoolId: string, gradeData: Record<string, unknown>): Promise<any>;
+    getKKM(subjectId: string, gradeLevel: number, schoolId: string): Promise<number | null>;
+    createNotification(schoolId: string, data: CoreNotificationPayload): Promise<any>;
+}

package/dist/core-integration.service.js

@@ -0,0 +1,258 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var CoreIntegrationService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreIntegrationService = void 0;
+const common_1 = require("@nestjs/common");
+const axios_1 = require("@nestjs/axios");
+const config_1 = require("@nestjs/config");
+const rxjs_1 = require("rxjs");
+const types_1 = require("./types");
+let CoreIntegrationService = CoreIntegrationService_1 = class CoreIntegrationService {
+    constructor(httpService, configService, options = {}) {
+        this.httpService = httpService;
+        this.configService = configService;
+        this.options = options;
+        this.logger = new common_1.Logger(CoreIntegrationService_1.name);
+        this.baseUrl = this.resolveRequired('baseUrl', 'CORE_SERVICE_URL');
+        this.appId = this.resolveRequired('appId', 'CORE_APP_ID', 'APP_ID');
+        this.appSecret = this.resolveRequired('appSecret', 'CORE_APP_SECRET', 'APP_SECRET');
+    }
+    resolveRequired(optionKey, ...envKeys) {
+        const fromOption = this.options[optionKey];
+        if (fromOption && typeof fromOption === 'string') {
+            return optionKey === 'baseUrl' ? fromOption.replace(/\/+$/, '') : fromOption;
+        }
+        for (const key of envKeys) {
+            const fromConfig = this.configService?.get(key);
+            if (fromConfig)
+                return optionKey === 'baseUrl' ? fromConfig.replace(/\/+$/, '') : fromConfig;
+            const fromEnv = process.env[key];
+            if (fromEnv)
+                return optionKey === 'baseUrl' ? fromEnv.replace(/\/+$/, '') : fromEnv;
+        }
+        throw new Error(`CoreIntegrationModule requires ${optionKey} or one of: ${envKeys.join(', ')}`);
+    }
+    getHeaders(schoolId, extraHeaders) {
+        return {
+            'X-App-ID': this.appId,
+            'X-App-Secret': this.appSecret,
+            'Content-Type': 'application/json',
+            ...(schoolId ? { 'X-School-ID': schoolId } : {}),
+            ...(extraHeaders ?? {}),
+        };
+    }
+    makeUrl(path) {
+        return `${this.baseUrl}/${path.replace(/^\/+/, '')}`;
+    }
+    extractStudentId(child) {
+        return child?.student_id || child?.student?.id || child?.studentUserId || child?.id || null;
+    }
+    async get(path, schoolId, options = {}) {
+        const { headers, ...requestOptions } = options;
+        const res = await (0, rxjs_1.firstValueFrom)(this.httpService.get(this.makeUrl(path), {
+            ...requestOptions,
+            headers: this.getHeaders(schoolId, headers),
+        }));
+        return res.data;
+    }
+    async post(path, schoolId, body, options = {}) {
+        const { headers, ...requestOptions } = options;
+        const res = await (0, rxjs_1.firstValueFrom)(this.httpService.post(this.makeUrl(path), body, {
+            ...requestOptions,
+            headers: this.getHeaders(schoolId, headers),
+        }));
+        return res.data;
+    }
+    async put(path, schoolId, body, options = {}) {
+        const { headers, ...requestOptions } = options;
+        const res = await (0, rxjs_1.firstValueFrom)(this.httpService.put(this.makeUrl(path), body, {
+            ...requestOptions,
+            headers: this.getHeaders(schoolId, headers),
+        }));
+        return res.data;
+    }
+    async patch(path, schoolId, body, options = {}) {
+        const { headers, ...requestOptions } = options;
+        const res = await (0, rxjs_1.firstValueFrom)(this.httpService.patch(this.makeUrl(path), body, {
+            ...requestOptions,
+            headers: this.getHeaders(schoolId, headers),
+        }));
+        return res.data;
+    }
+    async delete(path, schoolId, options = {}) {
+        const { headers, ...requestOptions } = options;
+        const res = await (0, rxjs_1.firstValueFrom)(this.httpService.delete(this.makeUrl(path), {
+            ...requestOptions,
+            headers: this.getHeaders(schoolId, headers),
+        }));
+        return res.data;
+    }
+    async getParentChildrenByUserId(parentUserId, schoolId) {
+        try {
+            const data = await this.get(`parents/by-user/${parentUserId}/children`, schoolId);
+            return data?.children || data?.data?.children || [];
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                return [];
+            }
+            this.logger.error(`Failed to fetch parent children: ${error.message}`);
+            throw new Error('Core service unavailable: unable to fetch parent children');
+        }
+    }
+    async getParentChildIdsByUserId(parentUserId, schoolId) {
+        const children = await this.getParentChildrenByUserId(parentUserId, schoolId);
+        return children
+            .map((child) => this.extractStudentId(child))
+            .filter((studentId) => !!studentId);
+    }
+    async resolveParentStudentScope(parentUserId, schoolId, requestedStudentId) {
+        const childIds = await this.getParentChildIdsByUserId(parentUserId, schoolId);
+        if (childIds.length === 0) {
+            throw new common_1.ForbiddenException('Parent has no linked children in this school');
+        }
+        if (!requestedStudentId) {
+            return childIds;
+        }
+        if (!childIds.includes(requestedStudentId)) {
+            throw new common_1.ForbiddenException('Child is not linked to this parent');
+        }
+        return [requestedStudentId];
+    }
+    async getStudents(schoolId, params = {}) {
+        try {
+            const data = await this.get('students', schoolId, { params });
+            return data?.data || data?.students || data || [];
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                return [];
+            }
+            this.logger.error(`Failed to fetch students: ${error.message}`);
+            throw new Error('Core service unavailable: unable to fetch students');
+        }
+    }
+    async getStudentsByClass(classId, schoolId) {
+        return this.getStudents(schoolId, { class_id: classId, status: 'active' });
+    }
+    async getStudent(studentId, schoolId) {
+        try {
+            return await this.get(`students/${studentId}`, schoolId);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to fetch student ${studentId}: ${error.message}`);
+            return null;
+        }
+    }
+    async findStudentByEmail(email, schoolId) {
+        try {
+            const data = await this.get('students', schoolId, { params: { q: email, limit: 1 } });
+            const list = data?.data || data?.students || data || [];
+            return Array.isArray(list) && list.length > 0 ? list[0] : null;
+        }
+        catch (error) {
+            this.logger.warn(`Failed to find student by email ${email}: ${error.message}`);
+            return null;
+        }
+    }
+    async getTeacher(teacherId, schoolId) {
+        try {
+            const data = await this.get(`teachers/${teacherId}`, schoolId);
+            return data?.data || data;
+        }
+        catch (error) {
+            this.logger.error(`Failed to fetch teacher: ${error.message}`);
+            return null;
+        }
+    }
+    async getClasses(schoolId) {
+        try {
+            const data = await this.get('classes', schoolId);
+            return data?.data || data || [];
+        }
+        catch (error) {
+            this.logger.error(`Failed to fetch classes: ${error.message}`);
+            throw new Error('Core service unavailable: unable to fetch classes');
+        }
+    }
+    async getTeachers(schoolId) {
+        try {
+            const data = await this.get('teachers', schoolId);
+            const body = data?.data || data || {};
+            return body?.data || body || [];
+        }
+        catch (error) {
+            this.logger.error(`Failed to fetch teachers: ${error.message}`);
+            throw new Error('Core service unavailable: unable to fetch teachers');
+        }
+    }
+    async getSubjects(schoolId, params = {}) {
+        const data = await this.get('subjects', schoolId, { params });
+        return data?.data || data || [];
+    }
+    async getCurriculums(schoolId, params = {}) {
+        const data = await this.get('curriculum', schoolId, { params });
+        return data?.data || data || [];
+    }
+    async getAcademicCalendar(schoolId, params = {}) {
+        const data = await this.get('academic-calendar', schoolId, { params });
+        return data?.data || data || [];
+    }
+    async getRooms(schoolId, params = {}) {
+        const data = await this.get('rooms', schoolId, { params });
+        return data?.data || data || [];
+    }
+    async pushGradeToCore(schoolId, gradeData) {
+        try {
+            return await this.post('grades/sync', schoolId, gradeData);
+        }
+        catch (error) {
+            this.logger.error(`Failed to push grade to core: ${error.message}`);
+            throw error;
+        }
+    }
+    async getKKM(subjectId, gradeLevel, schoolId) {
+        try {
+            const data = await this.get('kkm', schoolId, {
+                params: { subject_id: subjectId, grade_level: gradeLevel },
+            });
+            const list = data?.data || data || [];
+            const found = Array.isArray(list) ? list.find((k) => k.subject_id === subjectId) : null;
+            return found?.kkm_score ?? null;
+        }
+        catch (error) {
+            this.logger.warn(`Failed to fetch KKM: ${error.message}`);
+            return null;
+        }
+    }
+    async createNotification(schoolId, data) {
+        try {
+            return await this.post('notifications', schoolId, data);
+        }
+        catch (error) {
+            this.logger.warn(`Failed to create notification: ${error.message}`);
+            return null;
+        }
+    }
+};
+exports.CoreIntegrationService = CoreIntegrationService;
+exports.CoreIntegrationService = CoreIntegrationService = CoreIntegrationService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Optional)()),
+    __param(2, (0, common_1.Inject)(types_1.CORE_INTEGRATION_OPTIONS)),
+    __metadata("design:paramtypes", [axios_1.HttpService,
+        config_1.ConfigService, Object])
+], CoreIntegrationService);

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './core-integration.module';
+export * from './core-integration.service';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core-integration.module"), exports);
+__exportStar(require("./core-integration.service"), exports);
+__exportStar(require("./types"), exports);

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+export interface CoreIntegrationConfig {
+    baseUrl?: string;
+    appId?: string;
+    appSecret?: string;
+    timeout?: number;
+}
+export interface CoreRequestOptions {
+    params?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    timeout?: number;
+    [key: string]: unknown;
+}
+export interface CoreNotificationPayload {
+    user_id: string;
+    type: string;
+    title: string;
+    message: string;
+    reference?: string;
+    reference_id?: string;
+    action_url?: string;
+}
+export declare const CORE_INTEGRATION_OPTIONS = "CORE_INTEGRATION_OPTIONS";

package/dist/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_INTEGRATION_OPTIONS = void 0;
+exports.CORE_INTEGRATION_OPTIONS = 'CORE_INTEGRATION_OPTIONS';

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@loka-sms/core-integration-be",
+  "version": "0.0.1",
+  "description": "Internal NestJS client for service-to-service access to Loka SMS Core APIs",
+  "license": "MIT",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@nestjs/axios": "^4.0.0",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/config": "^4.0.0",
+    "rxjs": "^7.8.0"
+  },
+  "devDependencies": {
+    "@nestjs/axios": "^4.0.1",
+    "@nestjs/common": "^11.1.19",
+    "@nestjs/config": "^4.0.4",
+    "@types/node": "^22.0.0",
+    "rimraf": "^6.0.1",
+    "rxjs": "^7.8.1",
+    "typescript": "^5.7.3"
+  },
+  "keywords": [
+    "loka",
+    "sms",
+    "core",
+    "nestjs",
+    "integration"
+  ]
+}