@stoker-platform/cli 0.5.12

package/init-files/src/collections/Outbox.ts

@@ -0,0 +1,270 @@
+import type { CollectionSchema, GenerateSchema, StokerRecord, StokerRelationObject } from "@stoker-platform/types"
+import { MessageCircle, Send, SquarePen, Timer, TrendingUp, Users } from "lucide-react"
+import { blueField, greenField, redField } from "../utils.js"
+import { parseDate } from "@stoker-platform/utils"
+
+const Outbox: GenerateSchema = (sdk: "web" | "node"): CollectionSchema => {
+    return {
+        labels: {
+            collection: "Outbox",
+            record: "Outbox_Message",
+        },
+        access: {
+            operations: {
+                read: ["Admin", "User"],
+                create: ["Admin", "User"],
+                update: ["Admin", "User"],
+            },
+            attributeRestrictions: [
+                {
+                    type: "Record_Owner",
+                    roles: [{ role: "Admin" }, { role: "User" }],
+                },
+            ],
+        },
+        indexExemption: true,
+        preloadCache: {
+            roles: ["Admin", "User"],
+            range: {
+                fields: ["Saved_At"],
+                labels: ["Sent"],
+                start: -30,
+                end: 14,
+                selector: ["week", "month", "range"],
+            },
+        },
+        recordTitleField: "Subject",
+        fullTextSearch: ["Subject", "Message"],
+        softDelete: {
+            archivedField: "Archived",
+            timestampField: "Archived_At",
+            retentionPeriod: 7,
+        },
+        custom: {
+            async preWrite(operation, data) {
+                if (operation === "create") {
+                    data.Status = "Sending"
+                }
+            },
+            async postWrite(operation, data) {
+                if (operation === "create") {
+                    if (sdk === "web") {
+                        const { addRecord, updateRecord, getCurrentUser } = await import("@stoker-platform/web-client")
+                        const user = getCurrentUser()
+                        if (!user) throw new Error("User not found")
+                        const { claims } = user.token
+                        try {
+                            for (const [id, recipient] of Object.entries(data.Recipients as StokerRelationObject)) {
+                                await addRecord(["Inbox"], {
+                                    Subject: data.Subject,
+                                    Message: data.Message,
+                                    Recipient: {
+                                        [id]: {
+                                            Collection_Path: ["Users"],
+                                            Name: recipient.Name,
+                                        },
+                                    },
+                                    Recipients: data.Recipients,
+                                    Status: "Unread",
+                                    Sender: {
+                                        [claims.doc as string]: {
+                                            Collection_Path: ["Users"],
+                                            Name: user?.displayName,
+                                        },
+                                    },
+                                    Outbox_Message: data.id,
+                                })
+                            }
+                        } catch (error) {
+                            await updateRecord(["Outbox"], data.id, {
+                                Status: "Failed",
+                            })
+                            console.error(error)
+                        }
+                    } else {
+                        const { addRecord, updateRecord, getUser } = await import("@stoker-platform/node-client")
+                        if (data.Created_By === "System") return
+                        const user = await getUser(data.Created_By)
+                        try {
+                            for (const [id, recipient] of Object.entries(data.Recipients as StokerRelationObject)) {
+                                await addRecord(["Inbox"], {
+                                    Subject: data.Subject,
+                                    Message: data.Message,
+                                    Recipient: {
+                                        [id]: {
+                                            Collection_Path: ["Users"],
+                                            Name: recipient.Name,
+                                        },
+                                    },
+                                    Recipients: data.Recipients,
+                                    Status: "Unread",
+                                    Sender: {
+                                        [user.customClaims?.doc as string]: {
+                                            Collection_Path: ["Users"],
+                                            Name: user.displayName,
+                                        },
+                                    },
+                                    Outbox_Message: data.id,
+                                })
+                            }
+                        } catch (error) {
+                            await updateRecord(["Outbox"], data.id, {
+                                Status: "Failed",
+                            })
+                            throw error
+                        }
+                    }
+                }
+            },
+        },
+        admin: {
+            navbarPosition: 2,
+            titles: {
+                collection: "Outbox",
+                record: "Message",
+            },
+            icon: Send as React.FC,
+            itemsPerPage: 20,
+            defaultRangeSelector: "range",
+            defaultSort: {
+                field: "Sent",
+                direction: "desc",
+            },
+            filters: [
+                {
+                    type: "relation",
+                    field: "Recipients",
+                },
+            ],
+        },
+        fields: [
+            {
+                name: "Sent",
+                type: "Computed",
+                async formula(record?: StokerRecord) {
+                    if (!record) return ""
+                    if (sdk === "web") {
+                        const { displayDate } = await import("@stoker-platform/web-client")
+                        return displayDate(record.Saved_At)
+                    } else {
+                        const { displayDate } = await import("@stoker-platform/node-client")
+                        return displayDate(record.Saved_At)
+                    }
+                },
+                admin: {
+                    condition: {
+                        form(operation) {
+                            return operation === "update"
+                        },
+                    },
+                    icon: {
+                        component: Timer as React.FC,
+                        className: blueField,
+                    },
+                    hidden: "md",
+                    sort(record?: StokerRecord) {
+                        return parseDate(record?.Sent)
+                    },
+                },
+            },
+            {
+                name: "Recipients",
+                type: "ManyToMany",
+                collection: "Users",
+                required: true,
+                includeFields: ["Name"],
+                titleField: "Name",
+                dependencyFields: [{ field: "Name", roles: ["Admin", "User"] }],
+                admin: {
+                    icon: {
+                        component: Users as React.FC,
+                        className: blueField,
+                    },
+                },
+                restrictUpdate: true,
+            },
+            {
+                name: "Subject",
+                type: "String",
+                required: true,
+                admin: {
+                    icon: {
+                        component: MessageCircle as React.FC,
+                        className: redField,
+                    },
+                },
+                restrictUpdate: true,
+            },
+            {
+                name: "Status",
+                type: "String",
+                values: ["Sending", "Success", "Failed"],
+                required: true,
+                admin: {
+                    badge(record?: StokerRecord) {
+                        if (!record) return true
+                        switch (record.Status) {
+                            case "Sending":
+                                return "primary"
+                            case "Success":
+                                return "secondary"
+                            case "Failed":
+                                return "destructive"
+                            default:
+                                return true
+                        }
+                    },
+                    readOnly: true,
+                    condition: {
+                        form(operation) {
+                            return operation !== "create"
+                        },
+                    },
+                    icon: {
+                        component: TrendingUp as React.FC,
+                        className: redField,
+                    },
+                    hidden: "lg",
+                },
+            },
+            {
+                name: "Message",
+                type: "Map",
+                required: true,
+                admin: {
+                    richText: true,
+                    condition: {
+                        list: false,
+                    },
+                    icon: {
+                        component: SquarePen as React.FC,
+                        className: greenField,
+                    },
+                },
+                restrictUpdate: true,
+            },
+            {
+                name: "Archived",
+                type: "Boolean",
+                admin: {
+                    condition: {
+                        list: false,
+                        form: false,
+                    },
+                },
+            },
+            {
+                name: "Archived_At",
+                type: "Timestamp",
+                admin: {
+                    condition: {
+                        list: false,
+                        form: false,
+                    },
+                },
+            },
+        ],
+    }
+}
+
+export default Outbox

package/init-files/src/collections/Settings.ts

@@ -0,0 +1,44 @@
+import type { CollectionSchema, GenerateSchema } from "@stoker-platform/types"
+import { blueField } from "../utils.js"
+import { Building2, SettingsIcon } from "lucide-react"
+
+const Settings: GenerateSchema = (): CollectionSchema => {
+    return {
+        labels: {
+            collection: "Settings",
+            record: "Settings",
+        },
+        singleton: true,
+        access: {
+            operations: {
+                assignable: ["Admin"],
+                read: ["Admin"],
+                create: ["Admin"],
+                update: ["Admin"],
+                delete: ["Admin"],
+            },
+        },
+        indexExemption: true,
+        recordTitleField: "Organization_Name",
+        admin: {
+            navbarPosition: 4,
+            icon: SettingsIcon as React.FC,
+        },
+        fields: [
+            {
+                name: "Organization_Name",
+                type: "String",
+                required: true,
+                admin: {
+                    label: "Organization Name",
+                    icon: {
+                        component: Building2 as React.FC,
+                        className: blueField,
+                    },
+                },
+            },
+        ],
+    }
+}
+
+export default Settings

package/init-files/src/collections/Users.ts

@@ -0,0 +1,138 @@
+import type { GenerateSchema, CollectionSchema, StokerRecord } from "@stoker-platform/types"
+import { Activity, ChevronsUp, Image, Mail, User, Users2 } from "lucide-react"
+import { blueField, greenField, redField } from "../utils.js"
+
+const Users: GenerateSchema = (): CollectionSchema => {
+    return {
+        labels: {
+            collection: "Users",
+            record: "User",
+        },
+        auth: true,
+        access: {
+            auth: ["Admin"],
+            operations: {
+                assignable: ["Admin"],
+                read: ["Admin"],
+                create: ["Admin"],
+                update: ["Admin"],
+                delete: ["Admin"],
+            },
+        },
+        indexExemption: true,
+        enableWriteLog: true,
+        preloadCache: {
+            roles: ["Admin", "User"],
+        },
+        recordTitleField: "Name",
+        fullTextSearch: ["Name", "Email"],
+        admin: {
+            navbarPosition: 3,
+            icon: Users2 as React.FC,
+            statusField: {
+                field: "Enabled",
+                active: [true],
+                archived: [false],
+            },
+            itemsPerPage: 20,
+            filters: [
+                {
+                    type: "select",
+                    field: "Role",
+                    style: "buttons",
+                },
+            ],
+        },
+        fields: [
+            {
+                name: "Name",
+                type: "String",
+                required: true,
+                admin: {
+                    icon: {
+                        component: User as React.FC,
+                        className: blueField,
+                    },
+                },
+            },
+            {
+                name: "Enabled",
+                type: "Boolean",
+                required: true,
+                admin: {
+                    switch: true,
+                    hidden: "lg",
+                    icon: {
+                        component: Activity as React.FC,
+                        className: blueField,
+                    },
+                },
+            },
+            {
+                name: "Role",
+                type: "String",
+                values: ["Admin", "User"],
+                required: true,
+                admin: {
+                    badge(record?: StokerRecord) {
+                        if (!record) return true
+                        switch (record.Role) {
+                            case "Admin":
+                                return "destructive"
+                            case "User":
+                                return "primary"
+                            default:
+                                return true
+                        }
+                    },
+                    icon: {
+                        component: ChevronsUp as React.FC,
+                        className: blueField,
+                    },
+                },
+                sorting: true,
+            },
+            {
+                name: "Email",
+                type: "String",
+                email: true,
+                required: true,
+                unique: true,
+                admin: {
+                    hidden: "sm",
+                    icon: {
+                        component: Mail as React.FC,
+                        className: redField,
+                    },
+                },
+                sorting: true,
+            },
+            {
+                name: "Photo_URL",
+                type: "String",
+                pattern: "^https://firebasestorage\\.googleapis\\.com/.*$",
+                admin: {
+                    label: "Photo",
+                    image: true,
+                    hidden: "xl",
+                    icon: {
+                        component: Image as React.FC,
+                        className: greenField,
+                    },
+                },
+            },
+            {
+                name: "User_ID",
+                type: "String",
+                admin: {
+                    condition: {
+                        list: false,
+                        form: false,
+                    },
+                },
+            },
+        ],
+    }
+}
+
+export default Users

package/init-files/src/main.ts

@@ -0,0 +1,245 @@
+import type { DialogContent, GenerateGlobalConfig, GlobalConfig, WebUtilities } from "@stoker-platform/types"
+
+const globalConfig: GenerateGlobalConfig = (sdk, utils, context): GlobalConfig => {
+    const { setDialogContent, setConnectionStatus } = (context || {}) as {
+        setDialogContent: (dialogContent: DialogContent | null) => void
+        setConnectionStatus: (connectionStatus: "online" | "offline") => void
+    }
+    return {
+        appName: "Stoker",
+        roles: ["Admin", "User"],
+        timezone: "Australia/Melbourne",
+        disabledCollections: [],
+        auth: {
+            enableMultiFactorAuth: [],
+            authPersistenceType: "LOCAL",
+            offlinePersistenceType: "NONE",
+        },
+        firebase: {
+            enableEmulators() {
+                const { getEnv } = utils as WebUtilities
+                const env = getEnv()
+                const mode = env.MODE
+                const enable = mode === "development"
+                return enable
+            },
+            GDPRSettings: false,
+            enableAnalytics() {
+                const { getEnv } = utils as WebUtilities
+                const env = getEnv()
+                const mode = env.MODE
+                const enable = mode === "production"
+                return enable
+            },
+            analyticsSettings: {},
+            analyticsConsentSettings: {},
+            logLevel: {
+                dev: "info",
+            },
+            permissionsIndexExemption: true,
+            writeLogIndexExemption: [],
+            serverTimestampOptions: "estimate",
+        },
+        preload: {
+            sync: [],
+            async: ["Inbox", "Outbox"],
+        },
+        enableUserIDLogging: false,
+        onConnectionStatusChange(status) {
+            if (status === "Offline") {
+                setConnectionStatus("offline")
+                console.error("Connection lost")
+            }
+            if (status === "Online") {
+                setConnectionStatus("online")
+                console.info("Connection restored")
+            }
+        },
+        onVersionUpdate(versionInfo) {
+            if (sdk === "web") {
+                const payload = versionInfo.payload as { delay: boolean; tabs: boolean }
+                if (payload.delay) {
+                    setDialogContent({
+                        title: "An update is available",
+                        description: "The page will refresh in 30 seconds to update to the latest version.",
+                    })
+                    setTimeout(() => {
+                        window.location.reload()
+                    }, 30000)
+                }
+                if (payload.tabs) {
+                    setDialogContent({
+                        title: "An update is available",
+                        description:
+                            "Please close ALL of your open tabs to update to the latest version. A page refresh is not sufficient- please fully close all tabs.",
+                        disableClose: true,
+                    })
+                }
+            }
+        },
+        onMaintenanceUpdate(status) {
+            if (sdk === "web") {
+                const { setMaintenance } = context as { setMaintenance: (maintenance: boolean) => void }
+                if (status === "on") {
+                    setMaintenance(true)
+                } else {
+                    setMaintenance(false)
+                }
+            }
+        },
+        onFirestoreSlowConnection() {
+            setDialogContent({
+                title: "Slow connection detected",
+                description: "The app is experiencing a slow internet connection.",
+            })
+        },
+        async onFirestoreLoadFailure() {
+            if (sdk === "web") {
+                const { getAuth } = await import("firebase/auth")
+                const { sendAdminEmail } = await import("@stoker-platform/web-client")
+                const { currentUser } = getAuth()
+                if (!currentUser?.uid) throw new Error("Error sending Firestore load failure email")
+                await sendAdminEmail(
+                    "Firestore Load Failure Detected",
+                    `Firestore load failure detected for user ${currentUser.displayName} - ${currentUser.uid}`,
+                )
+                    .then(() => {
+                        window.location.reload()
+                    })
+                    .catch(() => {
+                        throw new Error("Error sending Firestore load failure email")
+                    })
+            }
+        },
+        onIndexedDBConnectionLost() {
+            setDialogContent({
+                title: "An error occurred",
+                description: "The app has experienced an issue and needs to refresh.",
+                disableClose: true,
+                buttons: [
+                    {
+                        label: "Refresh",
+                        onClick: () => {
+                            window.location.reload()
+                            setDialogContent(null)
+                        },
+                    },
+                ],
+            })
+        },
+        async onAppCheckTokenFailure(error) {
+            if (sdk === "web") {
+                if (
+                    error.code === "appCheck/throttled" ||
+                    error.code === "appCheck/initial-throttle" ||
+                    error.code === "appCheck/internal-error" ||
+                    error.code === "appCheck/recaptcha-error"
+                ) {
+                    setDialogContent({
+                        title: "Page refresh required",
+                        description: "The page needs to be refreshed for security reasons.",
+                        disableClose: true,
+                        buttons: [
+                            {
+                                label: "Refresh",
+                                onClick: () => {
+                                    window.location.reload()
+                                    setDialogContent(null)
+                                },
+                            },
+                        ],
+                    })
+                }
+            }
+        },
+        mail: {
+            emailVerification(verificationLink, appName) {
+                return {
+                    subject: `${appName} - Please verify your email address`,
+                    html: `Please verify your email address by clicking the link:
+                    </br>
+                    </br>
+                    <a href="${verificationLink}">${verificationLink}</a>`,
+                }
+            },
+        },
+        async postWriteError(operation, _data, docId, context, error) {
+            if (sdk === "web") {
+                const { sendAdminEmail } = await import("@stoker-platform/web-client")
+                const { getAuth } = await import("firebase/auth")
+                const { currentUser } = getAuth()
+                if (!currentUser?.uid) throw new Error("Error sending Firestore write operation failure email")
+                await sendAdminEmail(
+                    `Stoker Operation Failure`,
+                    `Operation Type: ${operation}\n\nUser: ${currentUser.displayName}\n\nUser ID: ${currentUser.uid}\n\nCollection: ${context.collection}\n\nDocument ID: ${docId}\n\nError Details:\n\n${JSON.stringify(error)}`,
+                ).catch(() => {
+                    throw new Error("Error sending Firestore write operation failure email")
+                })
+            } else {
+                console.log(JSON.stringify(error))
+            }
+        },
+        async postLogout(errorDetails) {
+            if (errorDetails.error) {
+                for (const instance of errorDetails.instances) {
+                    if (instance.code === "SIGN_OUT") {
+                        setDialogContent({
+                            title: "There was an error logging out",
+                            description:
+                                "You are still logged in. Please clear this browser's history to ensure that your sensitive data cannot be accessed by another user of this computer.",
+                        })
+                    } else if (instance.code === "CLEAR_CACHE") {
+                        setDialogContent({
+                            title: "There was an error clearing the cache",
+                            description:
+                                "Please clear this browser's history to ensure that your sensitive data cannot be accessed by another user of this computer.",
+                        })
+                    }
+                }
+            }
+        },
+        admin: {
+            meta: {
+                description: "A web app built using the Stoker platform.",
+            },
+            background: {
+                light: {
+                    color: "#1f4583",
+                    image: `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='80' height='105' viewBox='0 0 80 105'%3E%3Cg fill-rule='evenodd'%3E%3Cg id='death-star' fill='%233c66aa' fill-opacity='0.4'%3E%3Cpath d='M20 10a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V10zm15 35a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V45zM20 75a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V75zm30-65a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V10zm0 65a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V75zM35 10a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V10zM5 45a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V45zm0-35a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V10zm60 35a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V45zm0-35a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V10z' /%3E%3C/g%3E%3C/g%3E%3C/svg%3E")`,
+                },
+                dark: {
+                    color: "#575757",
+                    image: `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='80' height='105' viewBox='0 0 80 105'%3E%3Cg fill-rule='evenodd'%3E%3Cg id='death-star' fill='%23454545' fill-opacity='0.4'%3E%3Cpath d='M20 10a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V10zm15 35a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V45zM20 75a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V75zm30-65a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V10zm0 65a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V75zM35 10a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V10zM5 45a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V45zm0-35a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V10zm60 35a5 5 0 0 1 10 0v50a5 5 0 0 1-10 0V45zm0-35a5 5 0 0 1 10 0v20a5 5 0 0 1-10 0V10z' /%3E%3C/g%3E%3C/g%3E%3C/svg%3E")`,
+                },
+            },
+            menu: {
+                groups: [
+                    {
+                        title: "Messages",
+                        position: 1,
+                        collections: ["Inbox", "Outbox"],
+                    },
+                ],
+            },
+            dashboard: [
+                {
+                    kind: "reminder",
+                    collection: "Inbox",
+                    columns: ["Sender", "Subject"],
+                    title: "Unread Messages",
+                    constraints: [["Status", "==", "Unread"]],
+                },
+                {
+                    kind: "chart",
+                    collection: "Inbox",
+                    type: "area",
+                    dateField: "Saved_At",
+                    defaultRange: "30d",
+                    title: "Messages Over Time",
+                },
+            ],
+        },
+    }
+}
+
+export default globalConfig