@vicacha-devs/strapi-plugin-inbox 0.0.0-stage → 1.0.0

package/dist/server/src/content-types/subscriber/index.d.ts

@@ -0,0 +1,69 @@
+declare const _default: {
+    schema: {
+        kind: string;
+        collectionName: string;
+        info: {
+            singularName: string;
+            pluralName: string;
+            displayName: string;
+            description: string;
+        };
+        options: {
+            draftAndPublish: boolean;
+        };
+        pluginOptions: {
+            "content-manager": {
+                visible: boolean;
+            };
+            "content-type-builder": {
+                visible: boolean;
+            };
+        };
+        attributes: {
+            email: {
+                type: string;
+                required: boolean;
+                unique: boolean;
+            };
+            fullName: {
+                type: string;
+            };
+            phone: {
+                type: string;
+            };
+            locale: {
+                type: string;
+                default: string;
+            };
+            topics: {
+                type: string;
+                default: string[];
+            };
+            status: {
+                type: string;
+                enum: string[];
+                default: string;
+                required: boolean;
+            };
+            confirmToken: {
+                type: string;
+                private: boolean;
+            };
+            unsubscribeToken: {
+                type: string;
+                required: boolean;
+                private: boolean;
+            };
+            confirmedAt: {
+                type: string;
+            };
+            unsubscribedAt: {
+                type: string;
+            };
+            sourceFormSlug: {
+                type: string;
+            };
+        };
+    };
+};
+export default _default;

package/dist/server/src/content-types/subscriber/schema.json.d.ts

@@ -0,0 +1,69 @@
+declare const _default: {
+  "kind": "collectionType",
+  "collectionName": "inbox_subscribers",
+  "info": {
+    "singularName": "subscriber",
+    "pluralName": "subscribers",
+    "displayName": "Inbox Subscriber",
+    "description": "Double Opt-In newsletter and community topic subscriber"
+  },
+  "options": {
+    "draftAndPublish": false
+  },
+  "pluginOptions": {
+    "content-manager": {
+      "visible": true
+    },
+    "content-type-builder": {
+      "visible": true
+    }
+  },
+  "attributes": {
+    "email": {
+      "type": "email",
+      "required": true,
+      "unique": true
+    },
+    "fullName": {
+      "type": "string"
+    },
+    "phone": {
+      "type": "string"
+    },
+    "locale": {
+      "type": "string",
+      "default": "es"
+    },
+    "topics": {
+      "type": "json",
+      "default": ["announcements"]
+    },
+    "status": {
+      "type": "enumeration",
+      "enum": ["pending", "confirmed", "unsubscribed"],
+      "default": "pending",
+      "required": true
+    },
+    "confirmToken": {
+      "type": "string",
+      "private": true
+    },
+    "unsubscribeToken": {
+      "type": "string",
+      "required": true,
+      "private": true
+    },
+    "confirmedAt": {
+      "type": "datetime"
+    },
+    "unsubscribedAt": {
+      "type": "datetime"
+    },
+    "sourceFormSlug": {
+      "type": "string"
+    }
+  }
+}
+;
+
+export default _default;

package/dist/server/src/controllers/caseworkHandlers.d.ts

@@ -0,0 +1,10 @@
+import { Core } from '@strapi/strapi';
+import { ControllerCtx } from './inboxController';
+export declare const createCaseworkHandlers: (strapi: Core.Strapi) => {
+    listSubmissions(ctx: ControllerCtx): Promise<void>;
+    updateCasework(ctx: ControllerCtx): Promise<void>;
+    scheduleBooking(ctx: ControllerCtx): Promise<void>;
+    issueCertificate(ctx: ControllerCtx): Promise<void>;
+    exportCsv(ctx: ControllerCtx): Promise<void>;
+    testCaptcha(ctx: ControllerCtx): Promise<void>;
+};

package/dist/server/src/controllers/communityHandlers.d.ts

@@ -0,0 +1,10 @@
+import { Core } from '@strapi/strapi';
+import { ControllerCtx } from './inboxController';
+export declare const createCommunityHandlers: (strapi: Core.Strapi) => {
+    subscribe(ctx: ControllerCtx): Promise<void>;
+    confirmSubscription(ctx: ControllerCtx): Promise<void>;
+    unsubscribe(ctx: ControllerCtx): Promise<void>;
+    listSubscribers(ctx: ControllerCtx): Promise<void>;
+    getActiveAlerts(ctx: ControllerCtx): Promise<void>;
+    upsertAlertBanner(ctx: ControllerCtx): Promise<void>;
+};

package/dist/server/src/controllers/formHandlers.d.ts

@@ -0,0 +1,14 @@
+import { Core } from '@strapi/strapi';
+import { ControllerCtx } from './inboxController';
+export declare const createFormHandlers: (strapi: Core.Strapi) => {
+    getSettings(ctx: ControllerCtx): Promise<void>;
+    updateSettings(ctx: ControllerCtx): Promise<void>;
+    listTemplates(ctx: ControllerCtx): Promise<void>;
+    listFormBuilderForms(ctx: ControllerCtx): Promise<void>;
+    syncFormBuilder(ctx: ControllerCtx): Promise<void>;
+    listForms(ctx: ControllerCtx): Promise<void>;
+    getFormBySlug(ctx: ControllerCtx): Promise<void>;
+    saveForm(ctx: ControllerCtx): Promise<void>;
+    createFromTemplate(ctx: ControllerCtx): Promise<void>;
+    submitForm(ctx: ControllerCtx): Promise<void>;
+};

package/dist/server/src/controllers/inboxController.d.ts

@@ -0,0 +1,40 @@
+import { Core } from '@strapi/strapi';
+export interface ControllerCtx {
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    request: {
+        body?: Record<string, unknown>;
+        ip?: string;
+        headers?: Record<string, string | undefined>;
+    };
+    set?: (header: string, value: string) => void;
+    status?: number;
+    body?: unknown;
+}
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    subscribe(ctx: ControllerCtx): Promise<void>;
+    confirmSubscription(ctx: ControllerCtx): Promise<void>;
+    unsubscribe(ctx: ControllerCtx): Promise<void>;
+    listSubscribers(ctx: ControllerCtx): Promise<void>;
+    getActiveAlerts(ctx: ControllerCtx): Promise<void>;
+    upsertAlertBanner(ctx: ControllerCtx): Promise<void>;
+    listSubmissions(ctx: ControllerCtx): Promise<void>;
+    updateCasework(ctx: ControllerCtx): Promise<void>;
+    scheduleBooking(ctx: ControllerCtx): Promise<void>;
+    issueCertificate(ctx: ControllerCtx): Promise<void>;
+    exportCsv(ctx: ControllerCtx): Promise<void>;
+    testCaptcha(ctx: ControllerCtx): Promise<void>;
+    getSettings(ctx: ControllerCtx): Promise<void>;
+    updateSettings(ctx: ControllerCtx): Promise<void>;
+    listTemplates(ctx: ControllerCtx): Promise<void>;
+    listFormBuilderForms(ctx: ControllerCtx): Promise<void>;
+    syncFormBuilder(ctx: ControllerCtx): Promise<void>;
+    listForms(ctx: ControllerCtx): Promise<void>;
+    getFormBySlug(ctx: ControllerCtx): Promise<void>;
+    saveForm(ctx: ControllerCtx): Promise<void>;
+    createFromTemplate(ctx: ControllerCtx): Promise<void>;
+    submitForm(ctx: ControllerCtx): Promise<void>;
+};
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,2 @@
+declare const controllers: Record<string, unknown>;
+export default controllers;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const destroy: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default destroy;

package/dist/server/src/index.d.ts

@@ -0,0 +1,2 @@
+declare const serverEntry: Record<string, unknown>;
+export default serverEntry;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/routes/admin.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: never[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/content-api.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: never[];
+            auth: boolean;
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,26 @@
+declare const _default: {
+    "content-api": {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: never[];
+                auth: boolean;
+            };
+        }[];
+    };
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: never[];
+            };
+        }[];
+    };
+};
+export default _default;

package/dist/server/src/services/alertService.d.ts

@@ -0,0 +1,16 @@
+import { Core } from '@strapi/strapi';
+import { AlertBannerRecord } from '../../../shared';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getActiveAlerts(params?: {
+        locale?: string;
+        nowIso?: string;
+    }): Promise<AlertBannerRecord[]>;
+    upsertAlertBanner(input: Partial<AlertBannerRecord> & {
+        code: string;
+        title: string;
+        message: string;
+    }): Promise<AlertBannerRecord>;
+};
+export default _default;

package/dist/server/src/services/docHelper.d.ts

@@ -0,0 +1,28 @@
+import { Core } from '@strapi/strapi';
+export interface DocumentServiceLike {
+    findMany(params?: {
+        limit?: number;
+        locale?: string;
+        status?: "draft" | "published";
+        filters?: Record<string, unknown>;
+        populate?: string[];
+        sort?: string;
+    }): Promise<Array<Record<string, unknown>>>;
+    findOne(params: {
+        documentId: string;
+        locale?: string;
+        populate?: string[];
+    }): Promise<Record<string, unknown> | null>;
+    create(params: {
+        data: Record<string, unknown>;
+        locale?: string;
+        status?: "draft" | "published";
+    }): Promise<Record<string, unknown>>;
+    update(params: {
+        documentId: string;
+        locale?: string;
+        status?: "draft" | "published";
+        data: Record<string, unknown>;
+    }): Promise<Record<string, unknown> | null>;
+}
+export declare function getDocuments(strapi: Core.Strapi, uid: string): DocumentServiceLike;

package/dist/server/src/services/formBuilderMapper.d.ts

@@ -0,0 +1,22 @@
+import { ChecklistItem, FormCategory, FormRecord, FormTranslation, SubmissionPriority } from '../../../shared';
+export interface EmbeddedInboxMetadata {
+    category?: FormCategory;
+    checklistTemplate?: ChecklistItem[];
+    translations?: Record<string, FormTranslation>;
+    active?: boolean;
+    submissionCount?: number;
+    department?: string;
+    defaultPriority?: SubmissionPriority;
+    honeypotField?: string;
+    webhookUrl?: string;
+    enableBookingBridge?: boolean;
+    defaultBookingServiceSlug?: string;
+    enableCertificateBridge?: boolean;
+    defaultCertificateTemplateId?: string;
+    localizedSubmitLabels?: Record<string, string>;
+    localizedSuccessMessages?: Record<string, string>;
+}
+export declare function sanitizePublicForm(form: FormRecord, locale?: string): FormRecord;
+export declare function toFormBuilderCmsPayload(form: FormRecord, existingCms?: Record<string, unknown> | null): Record<string, unknown>;
+export declare function fromFormBuilderCmsRow(cmsForm: Record<string, unknown>, existing?: FormRecord | null): FormRecord;
+export declare const mergeFormBuilderCmsIntoInboxForm: typeof fromFormBuilderCmsRow;

package/dist/server/src/services/formBuilderSync.d.ts

@@ -0,0 +1,13 @@
+import { Core } from '@strapi/strapi';
+import { FormBuilderCmsFormSummary, FormRecord } from '../../../shared';
+export declare function isFormBuilderCmsAvailable(strapi: Core.Strapi): boolean;
+export declare function countSubmissionsForForm(strapi: Core.Strapi, formId: number, slug: string): Promise<number>;
+export declare function listFormBuilderForms(strapi: Core.Strapi): Promise<{
+    available: boolean;
+    forms: FormBuilderCmsFormSummary[];
+}>;
+export declare function syncFormToBuilderCms(strapi: Core.Strapi, form: FormRecord): Promise<{
+    formBuilderId: number;
+    formBuilderSlug: string;
+} | null>;
+export declare function syncFormFromBuilderCms(strapi: Core.Strapi, cmsForm: Record<string, unknown>): Promise<FormRecord | null>;

package/dist/server/src/services/formService.d.ts

@@ -0,0 +1,40 @@
+import { Core } from '@strapi/strapi';
+import { FormBuilderCmsFormSummary, FormCategory, FormRecord } from '../../../shared';
+import { fromFormBuilderCmsRow, mergeFormBuilderCmsIntoInboxForm, sanitizePublicForm, toFormBuilderCmsPayload } from './formBuilderMapper';
+export { fromFormBuilderCmsRow, mergeFormBuilderCmsIntoInboxForm, sanitizePublicForm, toFormBuilderCmsPayload, };
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    isFormBuilderCmsAvailable(): boolean;
+    listFormBuilderForms(): Promise<{
+        available: boolean;
+        forms: FormBuilderCmsFormSummary[];
+    }>;
+    syncFormToBuilderCms(form: FormRecord): Promise<{
+        formBuilderId: number;
+        formBuilderSlug: string;
+    } | null>;
+    syncFormFromBuilderCms(cmsForm: Record<string, unknown>): Promise<FormRecord | null>;
+    syncWithFormBuilderCms(): Promise<{
+        available: boolean;
+        syncedToBuilder: number;
+        syncedFromBuilder: number;
+        forms: FormRecord[];
+    }>;
+    listForms(params?: {
+        category?: FormCategory;
+        activeOnly?: boolean;
+        locale?: string;
+        publicSafe?: boolean;
+    }): Promise<FormRecord[]>;
+    findBySlug(slug: string, options?: {
+        locale?: string;
+        publicSafe?: boolean;
+    }): Promise<FormRecord | null>;
+    saveForm(input: Partial<FormRecord> & {
+        slug: string;
+        title: string;
+    }): Promise<FormRecord>;
+    createFromTemplate(templateId: string, overrides?: Partial<FormRecord>): Promise<FormRecord>;
+};
+export default _default;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,2 @@
+declare const services: Record<string, unknown>;
+export default services;

package/dist/server/src/services/settings.d.ts

@@ -0,0 +1,9 @@
+import { Core } from '@strapi/strapi';
+import { InboxSettings } from '../../../shared';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getSettings(): Promise<InboxSettings>;
+    updateSettings(patch: Partial<InboxSettings>): Promise<InboxSettings>;
+};
+export default _default;

package/dist/server/src/services/submissionEcosystemBridges.d.ts

@@ -0,0 +1,21 @@
+import { Core } from '@strapi/strapi';
+import { SubmissionRecord } from '../../../shared';
+export declare function scheduleBookingFromSubmission(strapi: Core.Strapi, documentId: string, bookingInput: {
+    serviceSlug: string;
+    date: string;
+    startTime: string;
+    endTime?: string;
+    notes?: string;
+}): Promise<{
+    submission: SubmissionRecord;
+    bookingId: string;
+}>;
+export declare function issueCertificateFromSubmission(strapi: Core.Strapi, documentId: string, certInput?: {
+    templateSlug?: string;
+    recipientName?: string;
+    requireChecklistVerified?: boolean;
+}): Promise<{
+    submission: SubmissionRecord;
+    certificateNumber: string;
+}>;
+export declare function exportSubmissionsCsv(strapi: Core.Strapi, submissions: SubmissionRecord[], formSlug?: string): Promise<string>;

package/dist/server/src/services/submissionFormBuilderBridge.d.ts

@@ -0,0 +1,23 @@
+import { Core } from '@strapi/strapi';
+import { FormRecord, InboxSettings, SubmissionRecord } from '../../../shared';
+export declare function generateReferenceCode(now?: Date): string;
+export declare function mirrorSubmissionToFormBuilderCms(strapi: Core.Strapi, params: {
+    settings: InboxSettings;
+    form: FormRecord;
+    cleanedData: Record<string, unknown>;
+    ip: string;
+    userAgent: string;
+}): Promise<number | null>;
+export declare function resolveCmsSubmissionFormRef(cmsSubmission: Record<string, unknown>, meta?: {
+    formId?: number;
+    formSlug?: string;
+}): {
+    formId: number | null;
+    formSlug: string;
+};
+export declare function ingestFormBuilderSubmission(strapi: Core.Strapi, cmsSubmission: Record<string, unknown>, meta?: {
+    formId?: number;
+    formSlug?: string;
+    nowMs?: number;
+}): Promise<SubmissionRecord | null>;
+export declare function syncSubmissionsFromFormBuilderCms(strapi: Core.Strapi): Promise<number>;

package/dist/server/src/services/submissionService.d.ts

@@ -0,0 +1,58 @@
+import { Core } from '@strapi/strapi';
+import { ChecklistItem, FetchLike, SubmissionPriority, SubmissionRecord, SubmissionStatus } from '../../../shared';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    testCaptchaSecret(provider: "none" | "turnstile" | "recaptcha", secret: string, fetchImpl?: FetchLike): Promise<{
+        ok: boolean;
+        reason?: string;
+    }>;
+    submitForm(slug: string, payload: Record<string, unknown>, meta?: {
+        ip?: string;
+        userAgent?: string;
+        locale?: string;
+        captchaToken?: string;
+        nowMs?: number;
+        fetchImpl?: FetchLike;
+    }): Promise<SubmissionRecord>;
+    ingestFormBuilderSubmission(cmsSubmission: Record<string, unknown>, meta?: {
+        formId?: number;
+        formSlug?: string;
+        nowMs?: number;
+    }): Promise<SubmissionRecord | null>;
+    listSubmissions(filters?: {
+        formSlug?: string;
+        status?: SubmissionStatus;
+        priority?: SubmissionPriority;
+        department?: string;
+        limit?: number;
+    }): Promise<SubmissionRecord[]>;
+    updateCasework(documentId: string, patch: {
+        status?: SubmissionStatus;
+        priority?: SubmissionPriority;
+        department?: string;
+        staffNotes?: string;
+        assignedTo?: string;
+        checklistItems?: ChecklistItem[];
+    }): Promise<SubmissionRecord>;
+    scheduleBookingFromSubmission(documentId: string, bookingInput: {
+        serviceSlug: string;
+        date: string;
+        startTime: string;
+        endTime?: string;
+        notes?: string;
+    }): Promise<{
+        submission: SubmissionRecord;
+        bookingId: string;
+    }>;
+    issueCertificateFromSubmission(documentId: string, certInput?: {
+        templateSlug?: string;
+        recipientName?: string;
+        requireChecklistVerified?: boolean;
+    }): Promise<{
+        submission: SubmissionRecord;
+        certificateNumber: string;
+    }>;
+    exportCsv(formSlug?: string): Promise<string>;
+};
+export default _default;

package/dist/server/src/services/subscriberService.d.ts

@@ -0,0 +1,22 @@
+import { Core } from '@strapi/strapi';
+import { SubscriberRecord, SubscriberStatus } from '../../../shared';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    subscribe(input: {
+        email: string;
+        fullName?: string;
+        phone?: string;
+        locale?: string;
+        topics?: string[];
+        sourceFormSlug?: string;
+    }): Promise<SubscriberRecord>;
+    confirmSubscription(token: string): Promise<SubscriberRecord>;
+    unsubscribe(token: string): Promise<SubscriberRecord>;
+    listSubscribers(filters?: {
+        status?: SubscriberStatus;
+        topic?: string;
+        locale?: string;
+    }): Promise<SubscriberRecord[]>;
+};
+export default _default;

package/dist/shared/index.d.ts

@@ -0,0 +1 @@
+export * from '../../shared/index.js';