@mastra/auth-supabase 1.1.1-alpha.0 → 1.1.2-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -1,5 +1,18 @@
1
1
  # @mastra/auth-supabase
2
2
 
3
+ ## 1.1.2-alpha.0
4
+
5
+ ### Patch Changes
6
+
7
+ - dependencies updates: ([#19779](https://github.com/mastra-ai/mastra/pull/19779))
8
+ - Updated dependency [`@supabase/supabase-js@^2.110.8` ↗︎](https://www.npmjs.com/package/@supabase/supabase-js/v/2.110.8) (from `^2.108.0`, in `dependencies`)
9
+
10
+ ## 1.1.1
11
+
12
+ ### Patch Changes
13
+
14
+ - Improved auth package builds by removing the direct core dependency from auth providers while preserving the existing public auth APIs. ([#17142](https://github.com/mastra-ai/mastra/pull/17142))
15
+
3
16
  ## 1.1.1-alpha.0
4
17
 
5
18
  ### Patch Changes
@@ -1,31 +1,31 @@
1
- import { RegisteredLogger, IMastraLogger } from '../logger/index.js';
2
- import 'node:stream';
3
-
1
+ import { i as IMastraLogger, u as RegisteredLogger } from "../index-S1lgaKO7.js";
2
+ //#region src/base/MastraBase.d.ts
4
3
  declare class MastraBase {
5
- #private;
6
- component: RegisteredLogger;
7
- protected logger: IMastraLogger;
4
+ #private;
5
+ component: RegisteredLogger;
6
+ protected logger: IMastraLogger;
7
+ name?: string;
8
+ constructor({ component, name, rawConfig }: {
9
+ component?: RegisteredLogger;
8
10
  name?: string;
9
- constructor({ component, name, rawConfig, }: {
10
- component?: RegisteredLogger;
11
- name?: string;
12
- rawConfig?: Record<string, unknown>;
13
- });
14
- /**
15
- * Returns the raw storage configuration this primitive was created from,
16
- * or undefined if it was created from code.
17
- */
18
- toRawConfig(): Record<string, unknown> | undefined;
19
- /**
20
- * Sets the raw storage configuration for this primitive.
21
- * @internal
22
- */
23
- __setRawConfig(rawConfig: Record<string, unknown>): void;
24
- /**
25
- * Set the logger for the agent
26
- * @param logger
27
- */
28
- __setLogger(logger: IMastraLogger): void;
11
+ rawConfig?: Record<string, unknown>;
12
+ });
13
+ /**
14
+ * Returns the raw storage configuration this primitive was created from,
15
+ * or undefined if it was created from code.
16
+ */
17
+ toRawConfig(): Record<string, unknown> | undefined;
18
+ /**
19
+ * Sets the raw storage configuration for this primitive.
20
+ * @internal
21
+ */
22
+ __setRawConfig(rawConfig: Record<string, unknown>): void;
23
+ /**
24
+ * Set the logger for the agent
25
+ * @param logger
26
+ */
27
+ __setLogger(logger: IMastraLogger): void;
29
28
  }
30
-
29
+ //#endregion
31
30
  export { MastraBase };
31
+ //# sourceMappingURL=index.d.ts.map
@@ -0,0 +1,218 @@
1
+ import { Transform } from "stream";
2
+ //#region src/logger/index.d.ts
3
+ declare const RegisteredLogger: {
4
+ readonly AGENT: "AGENT";
5
+ readonly OBSERVABILITY: "OBSERVABILITY";
6
+ readonly AUTH: "AUTH";
7
+ readonly BROWSER: "BROWSER";
8
+ readonly NETWORK: "NETWORK";
9
+ readonly WORKFLOW: "WORKFLOW";
10
+ readonly LLM: "LLM";
11
+ readonly TTS: "TTS";
12
+ readonly VOICE: "VOICE";
13
+ readonly VECTOR: "VECTOR";
14
+ readonly BUNDLER: "BUNDLER";
15
+ readonly DEPLOYER: "DEPLOYER";
16
+ readonly MEMORY: "MEMORY";
17
+ readonly STORAGE: "STORAGE";
18
+ readonly EMBEDDINGS: "EMBEDDINGS";
19
+ readonly MCP_SERVER: "MCP_SERVER";
20
+ readonly SERVER_CACHE: "SERVER_CACHE";
21
+ readonly SERVER: "SERVER";
22
+ readonly WORKSPACE: "WORKSPACE";
23
+ readonly CHANNEL: "CHANNEL";
24
+ };
25
+ type RegisteredLogger = (typeof RegisteredLogger)[keyof typeof RegisteredLogger];
26
+ declare const LogLevel: {
27
+ readonly DEBUG: "debug";
28
+ readonly INFO: "info";
29
+ readonly WARN: "warn";
30
+ readonly ERROR: "error";
31
+ readonly NONE: "silent";
32
+ };
33
+ type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
34
+ interface BaseLogMessage {
35
+ runId?: string;
36
+ msg: string;
37
+ level: LogLevel;
38
+ time: Date;
39
+ pid: number;
40
+ hostname: string;
41
+ name: string;
42
+ }
43
+ declare abstract class LoggerTransport extends Transform {
44
+ constructor(opts?: any);
45
+ listLogsByRunId(_args: {
46
+ runId: string;
47
+ fromDate?: Date;
48
+ toDate?: Date;
49
+ logLevel?: LogLevel;
50
+ filters?: Record<string, any>;
51
+ page?: number;
52
+ perPage?: number;
53
+ }): Promise<{
54
+ logs: BaseLogMessage[];
55
+ total: number;
56
+ page: number;
57
+ perPage: number;
58
+ hasMore: boolean;
59
+ }>;
60
+ listLogs(_args?: {
61
+ fromDate?: Date;
62
+ toDate?: Date;
63
+ logLevel?: LogLevel;
64
+ filters?: Record<string, any>;
65
+ returnPaginationResults?: boolean;
66
+ page?: number;
67
+ perPage?: number;
68
+ }): Promise<{
69
+ logs: BaseLogMessage[];
70
+ total: number;
71
+ page: number;
72
+ perPage: number;
73
+ hasMore: boolean;
74
+ }>;
75
+ }
76
+ declare const createCustomTransport: (stream: Transform, listLogs?: LoggerTransport["listLogs"], listLogsByRunId?: LoggerTransport["listLogsByRunId"]) => LoggerTransport;
77
+ interface IMastraLogger {
78
+ debug(message: string, ...args: any[]): void;
79
+ info(message: string, ...args: any[]): void;
80
+ warn(message: string, ...args: any[]): void;
81
+ error(message: string, ...args: any[]): void;
82
+ trackException(error: Error, metadata?: Record<string, unknown>): void;
83
+ getTransports(): Map<string, LoggerTransport>;
84
+ listLogs(_transportId: string, _params?: {
85
+ fromDate?: Date;
86
+ toDate?: Date;
87
+ logLevel?: LogLevel;
88
+ filters?: Record<string, any>;
89
+ page?: number;
90
+ perPage?: number;
91
+ }): Promise<{
92
+ logs: BaseLogMessage[];
93
+ total: number;
94
+ page: number;
95
+ perPage: number;
96
+ hasMore: boolean;
97
+ }>;
98
+ listLogsByRunId(_args: {
99
+ transportId: string;
100
+ runId: string;
101
+ fromDate?: Date;
102
+ toDate?: Date;
103
+ logLevel?: LogLevel;
104
+ filters?: Record<string, any>;
105
+ page?: number;
106
+ perPage?: number;
107
+ }): Promise<{
108
+ logs: BaseLogMessage[];
109
+ total: number;
110
+ page: number;
111
+ perPage: number;
112
+ hasMore: boolean;
113
+ }>;
114
+ }
115
+ declare abstract class MastraLogger implements IMastraLogger {
116
+ protected name: string;
117
+ protected level: LogLevel;
118
+ protected transports: Map<string, LoggerTransport>;
119
+ constructor(options?: {
120
+ name?: string;
121
+ level?: LogLevel;
122
+ transports?: Record<string, LoggerTransport>;
123
+ });
124
+ abstract debug(message: string, ...args: any[]): void;
125
+ abstract info(message: string, ...args: any[]): void;
126
+ abstract warn(message: string, ...args: any[]): void;
127
+ abstract error(message: string, ...args: any[]): void;
128
+ getTransports(): Map<string, LoggerTransport>;
129
+ trackException(_error: Error, _metadata?: Record<string, unknown>): void;
130
+ listLogs(transportId: string, params?: {
131
+ fromDate?: Date;
132
+ toDate?: Date;
133
+ logLevel?: LogLevel;
134
+ filters?: Record<string, any>;
135
+ page?: number;
136
+ perPage?: number;
137
+ }): Promise<{
138
+ logs: BaseLogMessage[];
139
+ total: number;
140
+ page: number;
141
+ perPage: number;
142
+ hasMore: boolean;
143
+ }>;
144
+ listLogsByRunId({ transportId, runId, fromDate, toDate, logLevel, filters, page, perPage }: {
145
+ transportId: string;
146
+ runId: string;
147
+ fromDate?: Date;
148
+ toDate?: Date;
149
+ logLevel?: LogLevel;
150
+ filters?: Record<string, any>;
151
+ page?: number;
152
+ perPage?: number;
153
+ }): Promise<{
154
+ logs: BaseLogMessage[];
155
+ total: number;
156
+ page: number;
157
+ perPage: number;
158
+ hasMore: boolean;
159
+ }>;
160
+ }
161
+ type LogFilterContext = {
162
+ component?: RegisteredLogger;
163
+ level: LogLevel;
164
+ message: string;
165
+ args: unknown[];
166
+ };
167
+ type LogFilter = (ctx: LogFilterContext) => boolean;
168
+ interface ConsoleLoggerOptions {
169
+ name?: string;
170
+ level?: LogLevel;
171
+ component?: RegisteredLogger;
172
+ filter?: LogFilter;
173
+ }
174
+ declare class ConsoleLogger extends MastraLogger {
175
+ protected component?: RegisteredLogger;
176
+ protected filter?: LogFilter;
177
+ constructor(options?: ConsoleLoggerOptions);
178
+ child(componentOrBindings: RegisteredLogger | Record<string, unknown>): ConsoleLogger;
179
+ private shouldLog;
180
+ private prefix;
181
+ debug(message: string, ...args: any[]): void;
182
+ info(message: string, ...args: any[]): void;
183
+ warn(message: string, ...args: any[]): void;
184
+ error(message: string, ...args: any[]): void;
185
+ listLogs(_transportId: string, _params?: {
186
+ fromDate?: Date;
187
+ toDate?: Date;
188
+ logLevel?: LogLevel;
189
+ filters?: Record<string, any>;
190
+ page?: number;
191
+ perPage?: number;
192
+ }): Promise<{
193
+ logs: never[];
194
+ total: number;
195
+ page: number;
196
+ perPage: number;
197
+ hasMore: boolean;
198
+ }>;
199
+ listLogsByRunId(_args: {
200
+ transportId: string;
201
+ runId: string;
202
+ fromDate?: Date;
203
+ toDate?: Date;
204
+ logLevel?: LogLevel;
205
+ filters?: Record<string, any>;
206
+ page?: number;
207
+ perPage?: number;
208
+ }): Promise<{
209
+ logs: never[];
210
+ total: number;
211
+ page: number;
212
+ perPage: number;
213
+ hasMore: boolean;
214
+ }>;
215
+ }
216
+ //#endregion
217
+ export { LogFilter as a, LoggerTransport as c, createCustomTransport as d, IMastraLogger as i, MastraLogger as l, ConsoleLogger as n, LogFilterContext as o, ConsoleLoggerOptions as r, LogLevel as s, BaseLogMessage as t, RegisteredLogger as u };
218
+ //# sourceMappingURL=index-S1lgaKO7.d.ts.map
@@ -1,5 +1,5 @@
1
1
  import { MastraBase } from '../_types/@internal_core/dist/base/index.d.ts';
2
- import type { CredentialsResult, ISSOProvider, ISessionProvider, IUserProvider, Session, SSOCallbackResult, SSOLoginConfig, User } from '..';
2
+ import type { CredentialsResult, IAuthHttpHandler, IAuthInit, ICredentialsProvider, IOrganizationsProvider, ISSOProvider, ISessionProvider, IUserProvider, Session, SSOCallbackResult, SSOLoginConfig, User } from '..';
3
3
  import type { AuthorizeUserFn, MastraAuthConfig, MastraAuthRequest } from '../types/index.js';
4
4
  export interface MastraAuthProviderOptions<TUser = unknown> {
5
5
  name?: string;
@@ -14,7 +14,44 @@ export interface MastraAuthProviderOptions<TUser = unknown> {
14
14
  */
15
15
  public?: MastraAuthConfig['public'];
16
16
  }
17
- export declare abstract class MastraAuthProvider<TUser = unknown> extends MastraBase {
17
+ /**
18
+ * Structural description of the public surface of a `MastraAuthProvider`.
19
+ *
20
+ * Auth provider packages bundle their own copy of the `MastraAuthProvider`
21
+ * declaration, so provider class types cannot be compared nominally across
22
+ * package boundaries — `#private`/`protected` members would make otherwise
23
+ * identical copies mutually unassignable. Positions that accept user-supplied
24
+ * providers (e.g. `server.auth`, `CompositeAuth`) accept this interface
25
+ * instead of the class.
26
+ *
27
+ * Note: methods intentionally use method syntax (not property syntax) so they
28
+ * are checked bivariantly — providers with a narrower `TUser` must remain
29
+ * assignable to `IMastraAuthProvider<unknown>`.
30
+ */
31
+ export interface IMastraAuthProvider<TUser = unknown> {
32
+ name?: string;
33
+ /**
34
+ * Protected paths for the auth provider
35
+ */
36
+ protected?: MastraAuthConfig['protected'];
37
+ /**
38
+ * Public paths for the auth provider
39
+ */
40
+ public?: MastraAuthConfig['public'];
41
+ /**
42
+ * Authenticate a token and return the payload
43
+ */
44
+ authenticateToken(token: string, request: MastraAuthRequest): Promise<TUser | null>;
45
+ /**
46
+ * Authorize a user for a path and method
47
+ */
48
+ authorizeUser(user: TUser, request: MastraAuthRequest): Promise<boolean> | boolean;
49
+ /**
50
+ * Map an authenticated user to a memory resource id
51
+ */
52
+ mapUserToResourceId?(user: TUser): string | undefined | null;
53
+ }
54
+ export declare abstract class MastraAuthProvider<TUser = unknown> extends MastraBase implements IMastraAuthProvider<TUser> {
18
55
  protected?: MastraAuthConfig['protected'];
19
56
  public?: MastraAuthConfig['public'];
20
57
  mapUserToResourceId?(user: TUser): string | undefined | null;
@@ -35,11 +72,18 @@ export declare abstract class MastraAuthProvider<TUser = unknown> extends Mastra
35
72
  abstract authorizeUser(user: TUser, request: MastraAuthRequest): Promise<boolean> | boolean;
36
73
  protected registerOptions(opts?: MastraAuthProviderOptions<TUser>): void;
37
74
  }
75
+ export declare function isSSOProvider(p: unknown): p is ISSOProvider;
76
+ export declare function isSessionProvider(p: unknown): p is ISessionProvider;
77
+ export declare function isUserProvider(p: unknown): p is IUserProvider;
78
+ export declare function isCredentialsProvider(p: unknown): p is ICredentialsProvider;
79
+ export declare function isOrganizationsProvider(p: unknown): p is IOrganizationsProvider;
80
+ export declare function isAuthHttpHandler(p: unknown): p is IAuthHttpHandler;
81
+ export declare function hasAuthInit(p: unknown): p is IAuthInit;
38
82
  export declare class CompositeAuth extends MastraAuthProvider implements ISSOProvider<User>, ISessionProvider<Session>, IUserProvider<User> {
39
83
  private providers;
40
84
  private authenticatedProviderByObject;
41
85
  private authenticatedProviderByPrimitive;
42
- constructor(providers: MastraAuthProvider[]);
86
+ constructor(providers: IMastraAuthProvider[]);
43
87
  private findProvider;
44
88
  private rememberAuthenticatedProvider;
45
89
  private takeAuthenticatedProvider;