@tulip-systems/core 0.10.1 → 0.10.2

package/dist/modules/auth/plugins/admin.mjs

@@ -0,0 +1,18 @@
+import { admin } from "better-auth/plugins";
+
+//#region src/modules/auth/plugins/admin.ts
+/**
+* Admin plugin.
+*/
+function adminPlugin({ roles, ac, adminRoles, defaultRole, ...props }) {
+	return admin({
+		...props,
+		roles,
+		ac,
+		adminRoles: adminRoles ?? ["admin", "developer"],
+		defaultRole: defaultRole ?? "user"
+	});
+}
+
+//#endregion
+export { adminPlugin };

package/dist/modules/auth/plugins/email-otp.d.mts

@@ -0,0 +1,554 @@
+import { Email } from "../../emails/lib/service.server.mjs";
+import * as zod from "zod";
+import * as better_auth_plugins0 from "better-auth/plugins";
+import { emailOTP } from "better-auth/plugins";
+import * as better_auth0 from "better-auth";
+import * as better_call0 from "better-call";
+import * as zod_v4_core0 from "zod/v4/core";
+
+//#region src/modules/auth/plugins/email-otp.d.ts
+type EmailOtpOptions = Omit<NonNullable<Parameters<typeof emailOTP>[0]>, "sendVerificationOTP">;
+type EmailOtpPluginConfig = EmailOtpOptions & {
+  email: Email;
+  defaultFrom: string;
+};
+/**
+ * Email OTP plugin.
+ *
+ * Handles Better Auth email OTP flows and provides Tulip's default
+ * forgot-password email implementation.
+ */
+declare function emailOtpPlugin(config: EmailOtpPluginConfig): {
+  id: "email-otp";
+  version: string;
+  init(ctx: better_auth0.AuthContext): {
+    options: {
+      emailVerification: {
+        sendVerificationEmail(data: {
+          user: better_auth0.User;
+          url: string;
+          token: string;
+        }, request: Request | undefined): Promise<void>;
+      };
+    };
+  } | undefined;
+  endpoints: {
+    sendVerificationOTP: better_call0.StrictEndpoint<"/email-otp/send-verification-otp", {
+      method: "POST";
+      body: zod.ZodObject<{
+        email: zod.ZodString;
+        type: zod.ZodEnum<{
+          "sign-in": "sign-in";
+          "change-email": "change-email";
+          "email-verification": "email-verification";
+          "forget-password": "forget-password";
+        }>;
+      }, zod_v4_core0.$strip>;
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      success: {
+                        type: string;
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      success: boolean;
+    }>;
+    createVerificationOTP: better_call0.StrictEndpoint<string, {
+      method: "POST";
+      body: zod.ZodObject<{
+        email: zod.ZodString;
+        type: zod.ZodEnum<{
+          "sign-in": "sign-in";
+          "change-email": "change-email";
+          "email-verification": "email-verification";
+          "forget-password": "forget-password";
+        }>;
+      }, zod_v4_core0.$strip>;
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "string";
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, string>;
+    getVerificationOTP: better_call0.StrictEndpoint<string, {
+      method: "GET";
+      query: zod.ZodObject<{
+        email: zod.ZodString;
+        type: zod.ZodEnum<{
+          "sign-in": "sign-in";
+          "change-email": "change-email";
+          "email-verification": "email-verification";
+          "forget-password": "forget-password";
+        }>;
+      }, zod_v4_core0.$strip>;
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            "200": {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      otp: {
+                        type: string;
+                        nullable: boolean;
+                        description: string;
+                      };
+                    };
+                    required: string[];
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      otp: null;
+    } | {
+      otp: string;
+    }>;
+    checkVerificationOTP: better_call0.StrictEndpoint<"/email-otp/check-verification-otp", {
+      method: "POST";
+      body: zod.ZodObject<{
+        email: zod.ZodString;
+        type: zod.ZodEnum<{
+          "sign-in": "sign-in";
+          "change-email": "change-email";
+          "email-verification": "email-verification";
+          "forget-password": "forget-password";
+        }>;
+        otp: zod.ZodString;
+      }, zod_v4_core0.$strip>;
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      success: {
+                        type: string;
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      success: boolean;
+    }>;
+    verifyEmailOTP: better_call0.StrictEndpoint<"/email-otp/verify-email", {
+      method: "POST";
+      body: zod.ZodObject<{
+        email: zod.ZodString;
+        otp: zod.ZodString;
+      }, zod_v4_core0.$strip>;
+      metadata: {
+        openapi: {
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      status: {
+                        type: string;
+                        description: string;
+                        enum: boolean[];
+                      };
+                      token: {
+                        type: string;
+                        nullable: boolean;
+                        description: string;
+                      };
+                      user: {
+                        $ref: string;
+                      };
+                    };
+                    required: string[];
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      status: boolean;
+      token: string;
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      } & Record<string, any>;
+    } | {
+      status: boolean;
+      token: null;
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      } & Record<string, any>;
+    }>;
+    signInEmailOTP: better_call0.StrictEndpoint<"/sign-in/email-otp", {
+      method: "POST";
+      body: zod.ZodIntersection<zod.ZodObject<{
+        email: zod.ZodString;
+        otp: zod.ZodString;
+        name: zod.ZodOptional<zod.ZodString>;
+        image: zod.ZodOptional<zod.ZodString>;
+      }, zod_v4_core0.$strip>, zod.ZodRecord<zod.ZodString, zod.ZodAny>>;
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      token: {
+                        type: string;
+                        description: string;
+                      };
+                      user: {
+                        $ref: string;
+                      };
+                    };
+                    required: string[];
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      token: string;
+      user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+      };
+    }>;
+    requestPasswordResetEmailOTP: better_call0.StrictEndpoint<"/email-otp/request-password-reset", {
+      method: "POST";
+      body: zod.ZodObject<{
+        email: zod.ZodString;
+      }, zod_v4_core0.$strip>;
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      success: {
+                        type: string;
+                        description: string;
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      success: boolean;
+    }>;
+    forgetPasswordEmailOTP: better_call0.StrictEndpoint<"/forget-password/email-otp", {
+      method: "POST";
+      body: zod.ZodObject<{
+        email: zod.ZodString;
+      }, zod_v4_core0.$strip>;
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      success: {
+                        type: string;
+                        description: string;
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      success: boolean;
+    }>;
+    resetPasswordEmailOTP: better_call0.StrictEndpoint<"/email-otp/reset-password", {
+      method: "POST";
+      body: zod.ZodObject<{
+        email: zod.ZodString;
+        otp: zod.ZodString;
+        password: zod.ZodString;
+      }, zod_v4_core0.$strip>;
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      success: {
+                        type: string;
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      success: boolean;
+    }>;
+    requestEmailChangeEmailOTP: better_call0.StrictEndpoint<"/email-otp/request-email-change", {
+      method: "POST";
+      body: zod.ZodObject<{
+        newEmail: zod.ZodString;
+        otp: zod.ZodOptional<zod.ZodString>;
+      }, zod_v4_core0.$strip>;
+      use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+        session: {
+          session: Record<string, any> & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+          };
+          user: Record<string, any> & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          };
+        };
+      }>)[];
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      success: {
+                        type: string;
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      success: boolean;
+    }>;
+    changeEmailEmailOTP: better_call0.StrictEndpoint<"/email-otp/change-email", {
+      method: "POST";
+      body: zod.ZodObject<{
+        newEmail: zod.ZodString;
+        otp: zod.ZodString;
+      }, zod_v4_core0.$strip>;
+      use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+        session: {
+          session: Record<string, any> & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+          };
+          user: Record<string, any> & {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          };
+        };
+      }>)[];
+      metadata: {
+        openapi: {
+          operationId: string;
+          description: string;
+          responses: {
+            200: {
+              description: string;
+              content: {
+                "application/json": {
+                  schema: {
+                    type: "object";
+                    properties: {
+                      success: {
+                        type: string;
+                      };
+                    };
+                  };
+                };
+              };
+            };
+          };
+        };
+      };
+    }, {
+      success: boolean;
+    }>;
+  };
+  hooks: {
+    after: {
+      matcher(context: better_auth0.HookEndpointContext): boolean;
+      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
+    }[];
+  };
+  rateLimit: ({
+    pathMatcher(path: string): path is "/email-otp/send-verification-otp";
+    window: number;
+    max: number;
+  } | {
+    pathMatcher(path: string): path is "/email-otp/check-verification-otp";
+    window: number;
+    max: number;
+  } | {
+    pathMatcher(path: string): path is "/email-otp/verify-email";
+    window: number;
+    max: number;
+  } | {
+    pathMatcher(path: string): path is "/sign-in/email-otp";
+    window: number;
+    max: number;
+  } | {
+    pathMatcher(path: string): path is "/email-otp/request-password-reset";
+    window: number;
+    max: number;
+  } | {
+    pathMatcher(path: string): path is "/email-otp/reset-password";
+    window: number;
+    max: number;
+  } | {
+    pathMatcher(path: string): path is "/forget-password/email-otp";
+    window: number;
+    max: number;
+  } | {
+    pathMatcher(path: string): path is "/email-otp/request-email-change";
+    window: number;
+    max: number;
+  } | {
+    pathMatcher(path: string): path is "/email-otp/change-email";
+    window: number;
+    max: number;
+  })[];
+  options: better_auth_plugins0.EmailOTPOptions;
+  $ERROR_CODES: {
+    OTP_EXPIRED: better_auth0.RawError<"OTP_EXPIRED">;
+    INVALID_OTP: better_auth0.RawError<"INVALID_OTP">;
+    TOO_MANY_ATTEMPTS: better_auth0.RawError<"TOO_MANY_ATTEMPTS">;
+  };
+};
+//#endregion
+export { emailOtpPlugin };

package/dist/modules/auth/plugins/email-otp.mjs

@@ -0,0 +1,34 @@
+import { url } from "../../../lib/utils/url.mjs";
+import ForgetPasswordEmail from "../../../components/emails/forget-password-email.mjs";
+import { emailOTP } from "better-auth/plugins";
+
+//#region src/modules/auth/plugins/email-otp.ts
+/**
+* Email OTP plugin.
+*
+* Handles Better Auth email OTP flows and provides Tulip's default
+* forgot-password email implementation.
+*/
+function emailOtpPlugin(config) {
+	const { email: emailClient, defaultFrom, ...options } = config;
+	return emailOTP({
+		...options,
+		sendVerificationOTP: async ({ email, otp, type }) => {
+			if (type !== "forget-password") return;
+			const searchParams = new URLSearchParams();
+			searchParams.set("email", email);
+			searchParams.set("otp", otp);
+			const resetPasswordHref = url(`/auth/reset-password?${searchParams.toString()}`);
+			const result = await emailClient.emails.send({
+				from: defaultFrom,
+				to: email,
+				subject: "Wachtwoord herstellen",
+				react: ForgetPasswordEmail({ resetPasswordHref })
+			});
+			if (result.error) throw new Error(result.error.message);
+		}
+	});
+}
+
+//#endregion
+export { emailOtpPlugin };

package/dist/modules/config/lib/context.d.mts

@@ -1,17 +1,18 @@
 import { TDatabaseSchema } from "../../database/lib/types.mjs";
 import { Database } from "../../database/lib/service.server.mjs";
 import { Email } from "../../emails/lib/service.server.mjs";
-import { Auth } from "../../auth/handler/service.server.mjs";
+import { Auth, TAuthServerOptions } from "../../auth/handler/service.server.mjs";
 import { Storage } from "../../storage/lib/service.server.mjs";
+import { BetterAuthOptions } from "better-auth";
 
 //#region src/modules/config/lib/context.d.ts
-type TulipContext<TSchema extends TDatabaseSchema> = {
+type TulipContext<TSchema extends TDatabaseSchema, TOptions extends TAuthServerOptions> = {
   db: Database<TSchema>;
   schema: TSchema;
-  auth: Auth;
+  auth: Auth<TOptions>;
   email: Email;
   storage: Storage<TSchema>;
 };
-declare function createContext<TSchema extends TDatabaseSchema>(props: TulipContext<TSchema>): TulipContext<TSchema>;
+declare function createContext<TSchema extends TDatabaseSchema, TAuthOptions extends BetterAuthOptions = BetterAuthOptions>(props: TulipContext<TSchema, TAuthOptions>): TulipContext<TSchema, TAuthOptions>;
 //#endregion
 export { TulipContext, createContext };

package/dist/modules/data-tables/lib/converters/dto.d.mts

@@ -1,4 +1,5 @@
 import { TableQuerySchema } from "../validators.mjs";
+import { z as z$1 } from "zod";
 
 //#region src/modules/data-tables/lib/converters/dto.d.ts
 /**
@@ -18,6 +19,16 @@ type TableQueryPaginationResponse = {
   nextCursor: number | null;
   previousCursor: number | null;
 };
+declare const tableQueryPaginationResponseSchema: z$1.ZodObject<{
+  total: z$1.ZodNumber;
+  totalPages: z$1.ZodNumber;
+  limit: z$1.ZodNumber;
+  hasNextPage: z$1.ZodBoolean;
+  hasPreviousPage: z$1.ZodBoolean;
+  cursor: z$1.ZodNumber;
+  nextCursor: z$1.ZodNullable<z$1.ZodNumber>;
+  previousCursor: z$1.ZodNullable<z$1.ZodNumber>;
+}, z$1.core.$strip>;
 /**
  * Table query response input
  */
@@ -47,4 +58,4 @@ declare function createTableQueryResponse<TData extends object>({
   };
 };
 //#endregion
-export { TableQueryPaginationResponse, TableQueryResponse, createTableQueryResponse };
+export { TableQueryPaginationResponse, TableQueryResponse, createTableQueryResponse, tableQueryPaginationResponseSchema };

package/dist/modules/data-tables/lib/converters/dto.mjs

@@ -1,4 +1,16 @@
+import { z as z$1 } from "zod";
+
 //#region src/modules/data-tables/lib/converters/dto.ts
+const tableQueryPaginationResponseSchema = z$1.object({
+	total: z$1.number(),
+	totalPages: z$1.number(),
+	limit: z$1.number(),
+	hasNextPage: z$1.boolean(),
+	hasPreviousPage: z$1.boolean(),
+	cursor: z$1.number(),
+	nextCursor: z$1.number().nullable(),
+	previousCursor: z$1.number().nullable()
+});
 /**
 * Convert pagination to DB query
 */
@@ -21,4 +33,4 @@ function createTableQueryResponse({ data, input, total }) {
 }
 
 //#endregion
-export { createTableQueryResponse };
+export { createTableQueryResponse, tableQueryPaginationResponseSchema };

package/dist/modules/data-tables/lib/converters/filters.d.mts

@@ -1,6 +1,6 @@
+import { TDatabaseSchema } from "../../../database/lib/types.mjs";
 import { Database } from "../../../database/lib/service.server.mjs";
 import { SQL } from "drizzle-orm";
-import { TDatabaseSchema } from "@tulip-systems/core/config";
 
 //#region src/modules/data-tables/lib/converters/filters.d.ts
 /**