payload-zitadel-plugin 0.1.0

package/README.md

@@ -0,0 +1,75 @@
+# payload-zitadel-plugin
+
+[![NPM](https://nodei.co/npm/payload-zitadel-plugin.png)](https://npmjs.org/package/payload-zitadel-plugin)
+
+plugin for [Payload CMS](https://payloadcms.com), which enables authentication via Zitadel IdP. It uses [NextAuth.js](https://next-auth.js.org) under the hood.
+
+:boom: :boom: :boom:   works :100: with PayloadCMS version :three:   :boom: :boom: :boom:
+
+## Install
+
+```shell
+pnpm add payload-zitadel-plugin@0.1.0
+```
+
+## Configuration
+
+Initialize the plugin in Payload Config File. Change the parameters to connect to your Zitadel Instance.
+
+#### payload.config.ts
+
+```typescript
+import {buildConfig} from 'payload/config'
+import {ZitadelPluginProvider} from 'payload-zitadel-plugin'
+
+export const {zitadelPlugin, nextauthHandler} = ZitadelPluginProvider({
+    // interpolation text for the Login Button
+    externalProviderName: 'Test-IdP',
+    
+    // set to true if you want users to only be able to sign in via Zitadel
+    disableLocalStrategy: true,
+    
+    // in Zitadel create a new App->Web->PKCE
+    issuerUrl: process.env.ZITADEL_URL,
+    clientId: process.env.ZITADEL_CLIENT_ID,
+    
+    // following properties are only needed if you want to authenticate clients for the API
+    // if you are just using the CMS you can ignore all of them
+
+    // in Zitadel create a new App->API->JWT
+    enableAPI: true,
+    apiClientId: process.env.ZITADEL_API_CLIENT_ID,
+    apiKeyId: process.env.ZITADEL_API_KEY_ID,
+    apiKey: process.env.ZITADEL_API_KEY
+})
+
+export default buildConfig({
+    ...,
+    plugins: [
+        zitadelPlugin
+    ],
+    ...
+})
+```
+
+Optionally you could use an `.env.local` file for parameters:
+#### .env.local
+```dotenv
+ZITADEL_URL: 'https://idp.zitadel.url',
+ZITADEL_CLIENT_ID: '123456789012345678@project_name',
+ZITADEL_API_CLIENT_ID: '123456789123456789@project_name',
+ZITADEL_API_KEY_ID: '123456789012345678',
+ZITADEL_API_KEY: '-----BEGIN RSA PRIVATE KEY----- ... ----END RSA PRIVATE KEY-----'
+```
+
+### create route
+Unfortunately you need to manually create the following NextAuth.js route in your Next.js App (using App Router):
+
+### (nextauth)/api/auth/[...nextauth]/route.ts
+```typescript
+import {nextauthHandler} from '@payload-config'
+
+export {nextauthHandler as GET, nextauthHandler as POST}
+```
+
+## For an example look in this repository at the `dev` directory!

package/dist/LoginButton/button.d.ts

@@ -0,0 +1,3 @@
+import { CustomComponent } from 'payload/config';
+export declare const _LoginButton: CustomComponent;
+//# sourceMappingURL=button.d.ts.map

package/dist/LoginButton/button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"button.d.ts","sourceRoot":"","sources":["../../src/LoginButton/button.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAC,eAAe,EAAC,MAAM,gBAAgB,CAAA;AAM9C,eAAO,MAAM,YAAY,EAAE,eAa1B,CAAA"}

package/dist/LoginButton/button.js

@@ -0,0 +1,20 @@
+'use client';
+import React from 'react';
+import { signIn } from 'next-auth/react';
+import { Button } from '@payloadcms/ui/elements';
+import { useTranslation } from '@payloadcms/ui/providers/Translation';
+export const _LoginButton = ({ internalProviderName, externalProviderName })=>{
+    const { t } = useTranslation();
+    return /*#__PURE__*/ React.createElement("div", {
+        style: {
+            display: 'flex',
+            justifyContent: 'center'
+        }
+    }, /*#__PURE__*/ React.createElement(Button, {
+        onClick: ()=>signIn(internalProviderName)
+    }, t('zitadelPlugin:signIn', {
+        externalProviderName
+    })));
+};
+
+//# sourceMappingURL=button.js.map

package/dist/LoginButton/button.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/LoginButton/button.tsx"],"sourcesContent":["'use client'\n\nimport React from 'react'\nimport {signIn} from 'next-auth/react'\nimport {CustomComponent} from 'payload/config'\nimport {NestedKeysStripped} from '@payloadcms/translations'\nimport {Button} from '@payloadcms/ui/elements'\nimport {useTranslation} from '@payloadcms/ui/providers/Translation'\nimport {translations} from '../translations.js'\n\nexport const _LoginButton: CustomComponent = ({internalProviderName, externalProviderName}: {\n    internalProviderName: string,\n    externalProviderName: string\n}) => {\n    const {t} = useTranslation<typeof translations.en, NestedKeysStripped<typeof translations.en>>()\n\n    return (\n        <div style={{display: 'flex', justifyContent: 'center'}}>\n            <Button onClick={() => signIn(internalProviderName)}>\n                {t('zitadelPlugin:signIn', {externalProviderName})}\n            </Button>\n        </div>\n    )\n}"],"names":["React","signIn","Button","useTranslation","_LoginButton","internalProviderName","externalProviderName","t","div","style","display","justifyContent","onClick"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":"AAAA;AAEA,OAAOA,WAAW,QAAO;AACzB,SAAQC,MAAM,QAAO,kBAAiB;AAGtC,SAAQC,MAAM,QAAO,0BAAyB;AAC9C,SAAQC,cAAc,QAAO,uCAAsC;AAGnE,OAAO,MAAMC,eAAgC,CAAC,EAACC,oBAAoB,EAAEC,oBAAoB,EAGxF;IACG,MAAM,EAACC,CAAC,EAAC,GAAGJ;IAEZ,qBACI,oBAACK;QAAIC,OAAO;YAACC,SAAS;YAAQC,gBAAgB;QAAQ;qBAClD,oBAACT;QAAOU,SAAS,IAAMX,OAAOI;OACzBE,EAAE,wBAAwB;QAACD;IAAoB;AAIhE,EAAC"}

package/dist/LoginButton/index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare const LoginButton: ({ internalProviderName, externalProviderName }: {
+    internalProviderName: string;
+    externalProviderName: string;
+}) => () => React.JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/LoginButton/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/LoginButton/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAA;AAGzB,eAAO,MAAM,WAAW,mDAAkD;IACtE,oBAAoB,EAAE,MAAM,CAAC;IAC7B,oBAAoB,EAAE,MAAM,CAAA;CAC/B,4BAAkH,CAAA"}

package/dist/LoginButton/index.js

@@ -0,0 +1,8 @@
+import React from 'react';
+import { _LoginButton } from './button.js';
+export const LoginButton = ({ internalProviderName, externalProviderName })=>()=>/*#__PURE__*/ React.createElement(_LoginButton, {
+            internalProviderName: internalProviderName,
+            externalProviderName: externalProviderName
+        });
+
+//# sourceMappingURL=index.js.map

package/dist/LoginButton/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/LoginButton/index.tsx"],"sourcesContent":["import React from 'react'\nimport {_LoginButton} from './button.js'\n\nexport const LoginButton = ({internalProviderName, externalProviderName}: {\n    internalProviderName: string,\n    externalProviderName: string\n}) => () => <_LoginButton internalProviderName={internalProviderName} externalProviderName={externalProviderName}/>"],"names":["React","_LoginButton","LoginButton","internalProviderName","externalProviderName"],"rangeMappings":";;;;;","mappings":"AAAA,OAAOA,WAAW,QAAO;AACzB,SAAQC,YAAY,QAAO,cAAa;AAExC,OAAO,MAAMC,cAAc,CAAC,EAACC,oBAAoB,EAAEC,oBAAoB,EAGtE,GAAK,kBAAM,oBAACH;YAAaE,sBAAsBA;YAAsBC,sBAAsBA;WAAuB"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { LoginButton } from './LoginButton/index.js';
+import { ZitadelPluginProviderType } from './types.js';
+export { LoginButton };
+export declare const ZitadelPluginProvider: ZitadelPluginProviderType;
+//# 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":"AAEA,OAAO,EAAC,WAAW,EAAC,MAAM,wBAAwB,CAAA;AAGlD,OAAO,EAA0B,yBAAyB,EAAC,MAAM,YAAY,CAAA;AAI7E,OAAO,EAAC,WAAW,EAAC,CAAA;AAEpB,eAAO,MAAM,qBAAqB,EAAE,yBAoInC,CAAA"}

package/dist/index.js

@@ -0,0 +1,123 @@
+import NextAuth from 'next-auth';
+import { signOut } from 'next-auth/react';
+import { LoginButton } from './LoginButton/index.js';
+import { authOptions } from './options.js';
+import { zitadelStrategy } from './strategy.js';
+import { translations } from './translations.js';
+export { LoginButton };
+export const ZitadelPluginProvider = ({ authSlug = 'users', associatedIdFieldName = 'idp_id', disableLocalStrategy, disableDefaultLoginButton, internalProviderName = 'zitadel', externalProviderName = 'ZITADEL', issuerUrl, clientId, enableAPI, apiClientId, apiKeyId, apiKey })=>{
+    if ((issuerUrl ?? '').length == 0) throw new Error('ZITADEL-PLUGIN: ISSUER-URL IS EMPTY');
+    if ((clientId ?? '').length == 0) throw new Error('ZITADEL-PLUGIN: CLIENT-ID IS EMPTY');
+    if (enableAPI) {
+        if ((apiClientId ?? '').length == 0) throw new Error('ZITADEL-PLUGIN: API ENABLED, BUT API-CLIENT-ID IS EMPTY');
+        if ((apiKeyId ?? '').length == 0) throw new Error('ZITADEL-PLUGIN: API ENABLED, BUT API-KEY-ID IS EMPTY');
+        if ((apiKey ?? '').length == 0) throw new Error('ZITADEL-PLUGIN: API ENABLED, BUT API-KEY IS EMPTY');
+    }
+    const authOptionsProps = {
+        internalProviderName: internalProviderName,
+        issuerUrl: issuerUrl,
+        clientId: clientId
+    };
+    return {
+        zitadelPlugin: (incomingConfig)=>({
+                ...incomingConfig,
+                admin: {
+                    ...incomingConfig.admin,
+                    components: {
+                        ...incomingConfig.admin?.components,
+                        afterLogin: [
+                            ...incomingConfig.admin?.components?.afterLogin || [],
+                            ...disableDefaultLoginButton ? [] : [
+                                LoginButton({
+                                    internalProviderName,
+                                    externalProviderName
+                                })
+                            ]
+                        ]
+                    }
+                },
+                collections: (incomingConfig.collections || []).map((collection)=>({
+                        ...collection,
+                        ...collection.slug == authSlug ? {
+                            auth: {
+                                ...typeof collection.auth == 'boolean' ? {} : collection.auth,
+                                disableLocalStrategy: disableLocalStrategy ? disableLocalStrategy : (typeof collection.auth == 'boolean' ? {} : collection.auth)?.disableLocalStrategy,
+                                strategies: [
+                                    ...(typeof collection.auth == 'boolean' ? {} : collection.auth)?.strategies ?? [],
+                                    zitadelStrategy({
+                                        authSlug,
+                                        associatedIdFieldName,
+                                        ...authOptionsProps,
+                                        ...enableAPI ? {
+                                            enableAPI: true,
+                                            apiClientId: apiClientId,
+                                            apiKeyId: apiClientId,
+                                            apiKey: apiKey
+                                        } : {
+                                            enableAPI: undefined
+                                        }
+                                    })
+                                ]
+                            },
+                            fields: [
+                                ...collection.fields,
+                                {
+                                    name: associatedIdFieldName,
+                                    type: 'text',
+                                    unique: true,
+                                    required: true
+                                }
+                            ],
+                            hooks: {
+                                afterLogout: [
+                                    ()=>signOut()
+                                ]
+                            }
+                        } : {}
+                    })),
+                //would be a more developer-friendly alternative
+                //currently not working, maybe in future update
+                /*endpoints: [
+                ...incomingConfig.endpoints || [],
+                ...['get', 'post'].map(method => ({
+                    handler: NextAuth.default(authOptions(authOptionsProps)),
+                    method: method as 'get' | 'post',
+                    path: 'api/auth/*'
+                }))
+            ],*/ //current work around on creating a non-functional first user
+                async onInit (payload) {
+                    if (incomingConfig.onInit) await incomingConfig.onInit(payload);
+                    const existingUsers = await payload.find({
+                        collection: authSlug,
+                        limit: 1
+                    });
+                    if (existingUsers.docs.length === 0) {
+                        await payload.create({
+                            collection: authSlug,
+                            data: {
+                                email: 'delete.me@now.com',
+                                password: 'password',
+                                [associatedIdFieldName]: 'DELETE_ME'
+                            }
+                        });
+                    }
+                },
+                i18n: {
+                    ...incomingConfig.i18n,
+                    translations: {
+                        de: {
+                            ...incomingConfig.i18n?.translations?.de ?? {},
+                            ...translations.de
+                        },
+                        en: {
+                            ...incomingConfig.i18n?.translations?.en ?? {},
+                            ...translations.en
+                        }
+                    }
+                }
+            }),
+        nextauthHandler: NextAuth.default(authOptions(authOptionsProps))
+    };
+};
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import NextAuth from 'next-auth'\nimport {signOut} from 'next-auth/react'\nimport {LoginButton} from './LoginButton/index.js'\nimport {authOptions} from './options.js'\nimport {zitadelStrategy} from './strategy.js'\nimport {ZitadelAuthOptionsProps, ZitadelPluginProviderType} from './types.js'\nimport {translations} from './translations.js'\n\n\nexport {LoginButton}\n\nexport const ZitadelPluginProvider: ZitadelPluginProviderType = ({\n                                                                     authSlug = 'users',\n                                                                     associatedIdFieldName = 'idp_id',\n                                                                     disableLocalStrategy,\n                                                                     disableDefaultLoginButton,\n                                                                     internalProviderName = 'zitadel',\n                                                                     externalProviderName = 'ZITADEL',\n                                                                     issuerUrl,\n                                                                     clientId,\n                                                                     enableAPI,\n                                                                     apiClientId,\n                                                                     apiKeyId,\n                                                                     apiKey\n                                                                 }) => {\n    if ((issuerUrl ?? '').length == 0)\n        throw new Error('ZITADEL-PLUGIN: ISSUER-URL IS EMPTY')\n    if ((clientId ?? '').length == 0)\n        throw new Error('ZITADEL-PLUGIN: CLIENT-ID IS EMPTY')\n    if (enableAPI) {\n        if ((apiClientId ?? '').length == 0)\n            throw new Error('ZITADEL-PLUGIN: API ENABLED, BUT API-CLIENT-ID IS EMPTY')\n        if ((apiKeyId ?? '').length == 0)\n            throw new Error('ZITADEL-PLUGIN: API ENABLED, BUT API-KEY-ID IS EMPTY')\n        if ((apiKey ?? '').length == 0)\n            throw new Error('ZITADEL-PLUGIN: API ENABLED, BUT API-KEY IS EMPTY')\n    }\n    const authOptionsProps: ZitadelAuthOptionsProps = {\n        internalProviderName: internalProviderName,\n        issuerUrl: issuerUrl!,\n        clientId: clientId!\n    }\n    return {\n        zitadelPlugin: (incomingConfig) => ({\n            ...incomingConfig,\n            admin: {\n                ...incomingConfig.admin,\n                components: {\n                    ...incomingConfig.admin?.components,\n                    afterLogin: [\n                        ...incomingConfig.admin?.components?.afterLogin || [],\n                        ...(disableDefaultLoginButton ? [] : [LoginButton({\n                            internalProviderName,\n                            externalProviderName\n                        })])\n                    ]\n                }\n            },\n            collections: (incomingConfig.collections || []).map((collection) => ({\n                ...collection,\n                ...collection.slug == authSlug ? {\n                    auth: {\n                        ...(typeof collection.auth == 'boolean' ? {} : collection.auth),\n                        disableLocalStrategy: disableLocalStrategy ? disableLocalStrategy : (typeof collection.auth == 'boolean' ? {} : collection.auth)?.disableLocalStrategy,\n                        strategies: [\n                            ...(typeof collection.auth == 'boolean' ? {} : collection.auth)?.strategies ?? [],\n                            zitadelStrategy({\n                                authSlug,\n                                associatedIdFieldName,\n                                ...authOptionsProps,\n                                ...(enableAPI ? {\n                                    enableAPI: true,\n                                    apiClientId: apiClientId!,\n                                    apiKeyId: apiClientId!,\n                                    apiKey: apiKey!\n                                } : {enableAPI: undefined})\n                            })\n                        ]\n                    },\n                    fields: [\n                        ...collection.fields,\n                        {\n                            name: associatedIdFieldName,\n                            type: 'text',\n                            unique: true,\n                            required: true\n                        }\n                    ],\n                    hooks: {\n                        afterLogout: [\n                            () => signOut()\n                        ]\n                    }\n                } : {}\n            })),\n            //would be a more developer-friendly alternative\n            //currently not working, maybe in future update\n            /*endpoints: [\n                ...incomingConfig.endpoints || [],\n                ...['get', 'post'].map(method => ({\n                    handler: NextAuth.default(authOptions(authOptionsProps)),\n                    method: method as 'get' | 'post',\n                    path: 'api/auth/*'\n                }))\n            ],*/\n\n            //current work around on creating a non-functional first user\n            async onInit(payload) {\n                if (incomingConfig.onInit)\n                    await incomingConfig.onInit(payload)\n\n                const existingUsers = await payload.find({\n                    collection: authSlug,\n                    limit: 1\n                })\n\n                if (existingUsers.docs.length === 0) {\n                    await payload.create({\n                        collection: authSlug,\n                        data: {\n                            email: 'delete.me@now.com',\n                            password: 'password',\n                            [associatedIdFieldName]: 'DELETE_ME'\n                        }\n                    })\n                }\n            },\n            i18n: {\n                ...incomingConfig.i18n,\n                translations: {\n                    de: {\n                        ...incomingConfig.i18n?.translations?.de ?? {},\n                        ...translations.de\n                    },\n                    en: {\n                        ...incomingConfig.i18n?.translations?.en ?? {},\n                        ...translations.en\n                    }\n                }\n            }\n        }),\n        nextauthHandler: NextAuth.default(authOptions(authOptionsProps))\n    }\n}"],"names":["NextAuth","signOut","LoginButton","authOptions","zitadelStrategy","translations","ZitadelPluginProvider","authSlug","associatedIdFieldName","disableLocalStrategy","disableDefaultLoginButton","internalProviderName","externalProviderName","issuerUrl","clientId","enableAPI","apiClientId","apiKeyId","apiKey","length","Error","authOptionsProps","zitadelPlugin","incomingConfig","admin","components","afterLogin","collections","map","collection","slug","auth","strategies","undefined","fields","name","type","unique","required","hooks","afterLogout","onInit","payload","existingUsers","find","limit","docs","create","data","email","password","i18n","de","en","nextauthHandler","default"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/dist/options.d.ts

@@ -0,0 +1,3 @@
+import { ZitadelAuthOptionsType } from './types.js';
+export declare const authOptions: ZitadelAuthOptionsType;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,sBAAsB,EAAC,MAAM,YAAY,CAAA;AAEjD,eAAO,MAAM,WAAW,EAAE,sBAuCxB,CAAA"}

package/dist/options.js

@@ -0,0 +1,45 @@
+export const authOptions = ({ internalProviderName, issuerUrl, clientId })=>({
+        providers: [
+            {
+                id: internalProviderName,
+                name: internalProviderName,
+                type: 'oauth',
+                version: '2',
+                wellKnown: issuerUrl,
+                authorization: {
+                    params: {
+                        scope: 'openid email profile'
+                    }
+                },
+                idToken: true,
+                checks: [
+                    'pkce',
+                    'state'
+                ],
+                client: {
+                    token_endpoint_auth_method: 'none'
+                },
+                profile: async (profile)=>({
+                        id: profile.sub,
+                        name: profile.name,
+                        firstName: profile.given_name,
+                        lastName: profile.family_name,
+                        email: profile.email,
+                        loginName: profile.preferred_username,
+                        image: profile.picture
+                    }),
+                clientId
+            }
+        ],
+        callbacks: {
+            session: async ({ session, token })=>({
+                    ...session,
+                    user: {
+                        ...session.user,
+                        id: token.sub
+                    }
+                })
+        }
+    });
+
+//# sourceMappingURL=options.js.map

package/dist/options.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/options.ts"],"sourcesContent":["import {ZitadelAuthOptionsType} from './types.js'\n\nexport const authOptions: ZitadelAuthOptionsType = ({internalProviderName, issuerUrl, clientId}) => ({\n    providers: [\n        {\n            id: internalProviderName,\n            name: internalProviderName,\n            type: 'oauth',\n            version: '2',\n            wellKnown: issuerUrl,\n            authorization: {\n                params: {\n                    scope: 'openid email profile'\n                }\n            },\n            idToken: true,\n            checks: ['pkce', 'state'],\n            client: {\n                token_endpoint_auth_method: 'none'\n            },\n            profile: async (profile) => ({\n                id: profile.sub,\n                name: profile.name,\n                firstName: profile.given_name,\n                lastName: profile.family_name,\n                email: profile.email,\n                loginName: profile.preferred_username,\n                image: profile.picture\n            }),\n            clientId\n        }\n    ],\n    callbacks: {\n        session: async ({session, token}) => ({\n            ...session,\n            user: {\n                ...session.user,\n                id: token.sub\n            }\n        })\n    }\n})"],"names":["authOptions","internalProviderName","issuerUrl","clientId","providers","id","name","type","version","wellKnown","authorization","params","scope","idToken","checks","client","token_endpoint_auth_method","profile","sub","firstName","given_name","lastName","family_name","email","loginName","preferred_username","image","picture","callbacks","session","token","user"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,cAAsC,CAAC,EAACC,oBAAoB,EAAEC,SAAS,EAAEC,QAAQ,EAAC,GAAM,CAAA;QACjGC,WAAW;YACP;gBACIC,IAAIJ;gBACJK,MAAML;gBACNM,MAAM;gBACNC,SAAS;gBACTC,WAAWP;gBACXQ,eAAe;oBACXC,QAAQ;wBACJC,OAAO;oBACX;gBACJ;gBACAC,SAAS;gBACTC,QAAQ;oBAAC;oBAAQ;iBAAQ;gBACzBC,QAAQ;oBACJC,4BAA4B;gBAChC;gBACAC,SAAS,OAAOA,UAAa,CAAA;wBACzBZ,IAAIY,QAAQC,GAAG;wBACfZ,MAAMW,QAAQX,IAAI;wBAClBa,WAAWF,QAAQG,UAAU;wBAC7BC,UAAUJ,QAAQK,WAAW;wBAC7BC,OAAON,QAAQM,KAAK;wBACpBC,WAAWP,QAAQQ,kBAAkB;wBACrCC,OAAOT,QAAQU,OAAO;oBAC1B,CAAA;gBACAxB;YACJ;SACH;QACDyB,WAAW;YACPC,SAAS,OAAO,EAACA,OAAO,EAAEC,KAAK,EAAC,GAAM,CAAA;oBAClC,GAAGD,OAAO;oBACVE,MAAM;wBACF,GAAGF,QAAQE,IAAI;wBACf1B,IAAIyB,MAAMZ,GAAG;oBACjB;gBACJ,CAAA;QACJ;IACJ,CAAA,EAAE"}

package/dist/strategy.d.ts

@@ -0,0 +1,3 @@
+import { ZitadelStrategyType } from './types.js';
+export declare const zitadelStrategy: ZitadelStrategyType;
+//# sourceMappingURL=strategy.d.ts.map

package/dist/strategy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategy.d.ts","sourceRoot":"","sources":["../src/strategy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,mBAAmB,EAAC,MAAM,YAAY,CAAA;AAE9C,eAAO,MAAM,eAAe,EAAE,mBA+E5B,CAAA"}

package/dist/strategy.js

@@ -0,0 +1,74 @@
+import { getServerSession } from 'next-auth';
+import { authOptions } from './options.js';
+import jwt from 'jsonwebtoken';
+export const zitadelStrategy = ({ authSlug, associatedIdFieldName, internalProviderName, issuerUrl, clientId, enableAPI, apiClientId, apiKeyId, apiKey })=>({
+        name: internalProviderName,
+        authenticate: async ({ headers, payload })=>{
+            let idp_id;
+            if (enableAPI) {
+                // in case of incoming API call from the app
+                const authHeader = headers.get('Authorization');
+                if (authHeader?.includes('Bearer')) {
+                    const introspect = await fetch(`${process.env.ZITADEL_URL}/oauth/v2/introspect`, {
+                        method: 'post',
+                        headers: {
+                            'Content-Type': 'application/x-www-form-urlencoded'
+                        },
+                        body: new URLSearchParams({
+                            'client_assertion_type': 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
+                            'client_assertion': jwt.sign({}, apiKey, {
+                                algorithm: 'RS256',
+                                audience: issuerUrl,
+                                expiresIn: '1h',
+                                issuer: apiClientId,
+                                keyid: apiKeyId,
+                                subject: apiClientId
+                            }),
+                            'token': authHeader.split(' ')[1]
+                        })
+                    });
+                    if (introspect.ok) {
+                        const data = await introspect.json();
+                        if (data?.active) {
+                            idp_id = data.sub;
+                        }
+                    }
+                }
+            }
+            // in case of normal browsing
+            if (!idp_id) {
+                const session = await getServerSession(authOptions({
+                    internalProviderName,
+                    issuerUrl,
+                    clientId
+                }));
+                if (session?.user) idp_id = (session?.user).id;
+            }
+            // search for associated user; if not found, create one
+            if (idp_id) {
+                const { docs } = await payload.find({
+                    collection: authSlug,
+                    where: {
+                        [associatedIdFieldName]: {
+                            equals: idp_id
+                        }
+                    }
+                });
+                const id = docs.length ? docs[0].id : (await payload.create({
+                    collection: authSlug,
+                    data: {
+                        [associatedIdFieldName]: idp_id
+                    }
+                })).id;
+                return {
+                    collection: authSlug,
+                    id,
+                    email: ''
+                };
+            }
+            // Authentication failed
+            return null;
+        }
+    });
+
+//# sourceMappingURL=strategy.js.map

package/dist/strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/strategy.ts"],"sourcesContent":["import {getServerSession, User} from 'next-auth'\nimport {authOptions} from './options.js'\nimport jwt from 'jsonwebtoken'\nimport {ZitadelStrategyType} from './types.js'\n\nexport const zitadelStrategy: ZitadelStrategyType = ({\n                                                         authSlug,\n                                                         associatedIdFieldName,\n                                                         internalProviderName,\n                                                         issuerUrl,\n                                                         clientId,\n                                                         enableAPI,\n                                                         apiClientId,\n                                                         apiKeyId,\n                                                         apiKey\n                                                     }) => ({\n    name: internalProviderName,\n    authenticate: async ({headers, payload}) => {\n        let idp_id\n\n        if (enableAPI) {\n            // in case of incoming API call from the app\n            const authHeader = headers.get('Authorization')\n            if (authHeader?.includes('Bearer')) {\n                const introspect = await fetch(`${process.env.ZITADEL_URL}/oauth/v2/introspect`, {\n                    method: 'post',\n                    headers: {\n                        'Content-Type': 'application/x-www-form-urlencoded'\n                    },\n                    body: new URLSearchParams({\n                        'client_assertion_type': 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',\n                        'client_assertion': jwt.sign({}, apiKey, {\n                            algorithm: 'RS256',\n                            audience: issuerUrl,\n                            expiresIn: '1h',\n                            issuer: apiClientId,\n                            keyid: apiKeyId,\n                            subject: apiClientId\n                        }),\n                        'token': authHeader.split(' ')[1]\n                    })\n                })\n                if (introspect.ok) {\n                    const data = await introspect.json()\n                    if (data?.active) {\n                        idp_id = data.sub\n                    }\n                }\n            }\n        }\n\n        // in case of normal browsing\n        if (!idp_id) {\n            const session = await getServerSession(authOptions({internalProviderName, issuerUrl, clientId}))\n            if (session?.user)\n                idp_id = (session?.user as User & { id: string }).id\n        }\n\n        // search for associated user; if not found, create one\n        if (idp_id) {\n            const {docs} = await payload.find({\n                collection: authSlug,\n                where: {\n                    [associatedIdFieldName]: {\n                        equals: idp_id\n                    }\n                }\n            })\n            const id = docs.length ? docs[0].id : (await payload.create({\n                collection: authSlug,\n                data: {\n                    [associatedIdFieldName]: idp_id\n                }\n            })).id\n            return {\n                collection: authSlug,\n                id,\n                email: ''\n            }\n        }\n\n        // Authentication failed\n        return null\n    }\n})"],"names":["getServerSession","authOptions","jwt","zitadelStrategy","authSlug","associatedIdFieldName","internalProviderName","issuerUrl","clientId","enableAPI","apiClientId","apiKeyId","apiKey","name","authenticate","headers","payload","idp_id","authHeader","get","includes","introspect","fetch","process","env","ZITADEL_URL","method","body","URLSearchParams","sign","algorithm","audience","expiresIn","issuer","keyid","subject","split","ok","data","json","active","sub","session","user","id","docs","find","collection","where","equals","length","create","email"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAAQA,gBAAgB,QAAa,YAAW;AAChD,SAAQC,WAAW,QAAO,eAAc;AACxC,OAAOC,SAAS,eAAc;AAG9B,OAAO,MAAMC,kBAAuC,CAAC,EACIC,QAAQ,EACRC,qBAAqB,EACrBC,oBAAoB,EACpBC,SAAS,EACTC,QAAQ,EACRC,SAAS,EACTC,WAAW,EACXC,QAAQ,EACRC,MAAM,EACT,GAAM,CAAA;QACxDC,MAAMP;QACNQ,cAAc,OAAO,EAACC,OAAO,EAAEC,OAAO,EAAC;YACnC,IAAIC;YAEJ,IAAIR,WAAW;gBACX,4CAA4C;gBAC5C,MAAMS,aAAaH,QAAQI,GAAG,CAAC;gBAC/B,IAAID,YAAYE,SAAS,WAAW;oBAChC,MAAMC,aAAa,MAAMC,MAAM,CAAC,EAAEC,QAAQC,GAAG,CAACC,WAAW,CAAC,oBAAoB,CAAC,EAAE;wBAC7EC,QAAQ;wBACRX,SAAS;4BACL,gBAAgB;wBACpB;wBACAY,MAAM,IAAIC,gBAAgB;4BACtB,yBAAyB;4BACzB,oBAAoB1B,IAAI2B,IAAI,CAAC,CAAC,GAAGjB,QAAQ;gCACrCkB,WAAW;gCACXC,UAAUxB;gCACVyB,WAAW;gCACXC,QAAQvB;gCACRwB,OAAOvB;gCACPwB,SAASzB;4BACb;4BACA,SAASQ,WAAWkB,KAAK,CAAC,IAAI,CAAC,EAAE;wBACrC;oBACJ;oBACA,IAAIf,WAAWgB,EAAE,EAAE;wBACf,MAAMC,OAAO,MAAMjB,WAAWkB,IAAI;wBAClC,IAAID,MAAME,QAAQ;4BACdvB,SAASqB,KAAKG,GAAG;wBACrB;oBACJ;gBACJ;YACJ;YAEA,6BAA6B;YAC7B,IAAI,CAACxB,QAAQ;gBACT,MAAMyB,UAAU,MAAM1C,iBAAiBC,YAAY;oBAACK;oBAAsBC;oBAAWC;gBAAQ;gBAC7F,IAAIkC,SAASC,MACT1B,SAAS,AAACyB,CAAAA,SAASC,IAAG,EAA4BC,EAAE;YAC5D;YAEA,uDAAuD;YACvD,IAAI3B,QAAQ;gBACR,MAAM,EAAC4B,IAAI,EAAC,GAAG,MAAM7B,QAAQ8B,IAAI,CAAC;oBAC9BC,YAAY3C;oBACZ4C,OAAO;wBACH,CAAC3C,sBAAsB,EAAE;4BACrB4C,QAAQhC;wBACZ;oBACJ;gBACJ;gBACA,MAAM2B,KAAKC,KAAKK,MAAM,GAAGL,IAAI,CAAC,EAAE,CAACD,EAAE,GAAG,AAAC,CAAA,MAAM5B,QAAQmC,MAAM,CAAC;oBACxDJ,YAAY3C;oBACZkC,MAAM;wBACF,CAACjC,sBAAsB,EAAEY;oBAC7B;gBACJ,EAAC,EAAG2B,EAAE;gBACN,OAAO;oBACHG,YAAY3C;oBACZwC;oBACAQ,OAAO;gBACX;YACJ;YAEA,wBAAwB;YACxB,OAAO;QACX;IACJ,CAAA,EAAE"}

package/dist/translations.d.ts

@@ -0,0 +1,13 @@
+export declare const translations: {
+    de: {
+        zitadelPlugin: {
+            signIn: string;
+        };
+    };
+    en: {
+        zitadelPlugin: {
+            signIn: string;
+        };
+    };
+};
+//# sourceMappingURL=translations.d.ts.map

package/dist/translations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"translations.d.ts","sourceRoot":"","sources":["../src/translations.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;;;;;;;CAWxB,CAAA"}

package/dist/translations.js

@@ -0,0 +1,14 @@
+export const translations = {
+    de: {
+        zitadelPlugin: {
+            signIn: 'Mit {{externalProviderName}} anmelden'
+        }
+    },
+    en: {
+        zitadelPlugin: {
+            signIn: 'sign-in with {{externalProviderName}}'
+        }
+    }
+};
+
+//# sourceMappingURL=translations.js.map

package/dist/translations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/translations.ts"],"sourcesContent":["export const translations = {\n    de: {\n        zitadelPlugin: {\n            signIn: 'Mit {{externalProviderName}} anmelden'\n        }\n    },\n    en: {\n        zitadelPlugin: {\n            signIn: 'sign-in with {{externalProviderName}}'\n        }\n    }\n}"],"names":["translations","de","zitadelPlugin","signIn","en"],"rangeMappings":";;;;;;;;;;;","mappings":"AAAA,OAAO,MAAMA,eAAe;IACxBC,IAAI;QACAC,eAAe;YACXC,QAAQ;QACZ;IACJ;IACAC,IAAI;QACAF,eAAe;YACXC,QAAQ;QACZ;IACJ;AACJ,EAAC"}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+import { NextAuthOptions } from 'next-auth';
+import { AuthStrategy } from 'payload/auth';
+import { Config } from 'payload/config';
+export type ZitadelPluginProps = {
+    disableLocalStrategy?: true | undefined;
+    disableDefaultLoginButton?: true | undefined;
+    defaultLoginButtonTitle?: string;
+    externalProviderName?: string;
+} & Partial<ZitadelStrategyProps>;
+export type ZitadelPluginProviderType = (props: ZitadelPluginProps) => {
+    zitadelPlugin: (incomingConfig: Config) => Config;
+    nextauthHandler: any;
+};
+export type ZitadelAuthOptionsProps = {
+    internalProviderName: string;
+    issuerUrl: string;
+    clientId: string;
+};
+export type ZitadelAuthOptionsType = (props: ZitadelAuthOptionsProps) => NextAuthOptions;
+export type ZitadelAPIProps = {
+    enableAPI: true;
+    apiClientId: string;
+    apiKeyId: string;
+    apiKey: string;
+};
+export type ZitadelStrategyProps = ZitadelAuthOptionsProps & {
+    authSlug: string;
+    associatedIdFieldName: string;
+} & (ZitadelAPIProps | {
+    enableAPI?: undefined;
+} & Partial<ZitadelAPIProps>);
+export type ZitadelStrategyType = (props: ZitadelStrategyProps) => AuthStrategy;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,WAAW,CAAA;AACzC,OAAO,EAAC,YAAY,EAAC,MAAM,cAAc,CAAA;AACzC,OAAO,EAAC,MAAM,EAAC,MAAM,gBAAgB,CAAA;AAErC,MAAM,MAAM,kBAAkB,GAAG;IAC7B,oBAAoB,CAAC,EAAE,IAAI,GAAG,SAAS,CAAA;IACvC,yBAAyB,CAAC,EAAE,IAAI,GAAG,SAAS,CAAA;IAC5C,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAChC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAA;AAEjC,MAAM,MAAM,yBAAyB,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK;IACnE,aAAa,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,MAAM,CAAC;IAClD,eAAe,EAAE,GAAG,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IAClC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG,CAAC,KAAK,EAAE,uBAAuB,KAAK,eAAe,CAAA;AAExF,MAAM,MAAM,eAAe,GAAG;IAC1B,SAAS,EAAE,IAAI,CAAA;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,uBAAuB,GAAG;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB,EAAE,MAAM,CAAC;CACjC,GAAG,CAAC,eAAe,GAAG;IACnB,SAAS,CAAC,EAAE,SAAS,CAAA;CACxB,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC,CAAA;AAE7B,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,oBAAoB,KAAK,YAAY,CAAA"}

package/dist/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["import {NextAuthOptions} from 'next-auth'\nimport {AuthStrategy} from 'payload/auth'\nimport {Config} from 'payload/config'\n\nexport type ZitadelPluginProps = {\n    disableLocalStrategy?: true | undefined\n    disableDefaultLoginButton?: true | undefined\n    defaultLoginButtonTitle?: string\n    externalProviderName?: string\n} & Partial<ZitadelStrategyProps>\n\nexport type ZitadelPluginProviderType = (props: ZitadelPluginProps) => {\n    zitadelPlugin: (incomingConfig: Config) => Config,\n    nextauthHandler: any\n}\n\nexport type ZitadelAuthOptionsProps = {\n    internalProviderName: string,\n    issuerUrl: string,\n    clientId: string\n}\n\nexport type ZitadelAuthOptionsType = (props: ZitadelAuthOptionsProps) => NextAuthOptions\n\nexport type ZitadelAPIProps = {\n    enableAPI: true\n    apiClientId: string,\n    apiKeyId: string,\n    apiKey: string\n}\n\nexport type ZitadelStrategyProps = ZitadelAuthOptionsProps & {\n    authSlug: string,\n    associatedIdFieldName: string,\n} & (ZitadelAPIProps | {\n    enableAPI?: undefined\n} & Partial<ZitadelAPIProps>)\n\nexport type ZitadelStrategyType = (props: ZitadelStrategyProps) => AuthStrategy"],"names":[],"rangeMappings":"","mappings":"AAsCA,WAA+E"}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "payload-zitadel-plugin",
+  "version": "0.1.0",
+  "description": "plugin for Payload CMS, which enables authentication via Zitadel IdP",
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "WALX Tech e.K.",
+    "email": "x@walx.tech",
+    "url": "https://walx.tech"
+  },
+  "contributors": [
+    {
+      "name": "Ш41%",
+      "email": "_@w41x.io",
+      "url": "https://w41x.io"
+    }
+  ],
+  "homepage": "https://github.com/w41x/payload-zitadel-plugin#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/w41x/payload-zitadel-plugin.git"
+  },
+  "keywords": [
+    "payload",
+    "cms",
+    "plugin",
+    "zitadel"
+  ],
+  "bugs": {
+    "url": "https://github.com/w41x/payload-zitadel-plugin/issues"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@payloadcms/translations": "3.0.0-beta.47",
+    "@payloadcms/ui": "3.0.0-beta.47",
+    "jsonwebtoken": "^9.0.2",
+    "next": "^15.0.0-rc.0",
+    "next-auth": "^4.24.7",
+    "payload": "3.0.0-beta.47",
+    "react": "^19.0.0-rc-dfd30974ab-20240613",
+    "react-dom": "^19.0.0-rc-dfd30974ab-20240613"
+  },
+  "devDependencies": {
+    "@swc/cli": "^0.3.12",
+    "@swc/core": "^1.5.29",
+    "@types/jsonwebtoken": "^9.0.6",
+    "@types/node": "^20.14.2",
+    "@types/react": "^18.3.3",
+    "@types/react-dom": "^18.3.0",
+    "rimraf": "^5.0.7",
+    "typescript": "^5.6.0-dev.20240614"
+  },
+  "engines": {
+    "node": "^22.3.0"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "require": "./dist/types.js",
+      "types": "./dist/types.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "pnpm build:swc && pnpm build:types",
+    "build:swc": "swc src -d dist --config-file .swcrc --strip-leading-paths",
+    "build:types": "tsc --emitDeclarationOnly --outDir dist",
+    "clean": "rimraf {dist, tsconfig.tsbuildinfo}"
+  }
+}