target-supabase-sdk 0.2.0 → 0.2.2

package/src/trigger/trigger-manager.ts

@@ -0,0 +1,287 @@
+import type { NodeLoopContext } from "../node/node-runtime.base";
+import { createLogger, createScope, withModule } from "../shared/log";
+import { getErrorMessage } from "../shared/utils/error.utils";
+import {
+    LOG_TOPIC_TRIGGER,
+    TRIGGER_LOOP_INTERVAL_MS,
+    TRIGGER_RUNNER_DEFAULT_RETRY_COUNT,
+    TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS,
+} from "./trigger.constant";
+import type { RegisterTriggerRunnerOptions, TriggerRunnerContext, TriggerRunnerFn } from "./trigger.interface";
+
+export type { RegisterTriggerRunnerOptions, TriggerRunnerContext, TriggerRunnerFn } from "./trigger.interface";
+
+interface TriggerRunnerState {
+    key: string;
+    intervalMs: number;
+    fn: TriggerRunnerFn;
+    retryCount: number;
+    retryDelayMs: number;
+    timeoutMs: number | undefined;
+    nextRunAt: number;
+    running: boolean;
+}
+
+const runnerRegistry = new Map<string, TriggerRunnerState>();
+let registrationClosed = false;
+
+function normalizeRunnerKey(key: string): string {
+    const normalized = key.trim();
+    if (normalized.length === 0) {
+        throw new Error("[TriggerManager] key must be a non-empty string");
+    }
+    return normalized;
+}
+
+function tryNormalizeRunnerKey(key: string): string | null {
+    const normalized = key.trim();
+    return normalized.length > 0 ? normalized : null;
+}
+
+function validateRunnerOptions(options: RegisterTriggerRunnerOptions): void {
+    if (!Number.isFinite(options.intervalMs) || options.intervalMs < 1) {
+        throw new Error(`[TriggerManager] intervalMs must be a positive number, got ${options.intervalMs}`);
+    }
+    const retryCount = options.retryCount ?? TRIGGER_RUNNER_DEFAULT_RETRY_COUNT;
+    if (!Number.isInteger(retryCount) || retryCount < 0) {
+        throw new Error(`[TriggerManager] retryCount must be a non-negative integer, got ${retryCount}`);
+    }
+    const initialDelayMs = options.initialDelayMs ?? 0;
+    if (!Number.isFinite(initialDelayMs) || initialDelayMs < 0) {
+        throw new Error(`[TriggerManager] initialDelayMs must be a non-negative number, got ${initialDelayMs}`);
+    }
+    const retryDelayMs = options.retryDelayMs ?? TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS;
+    if (!Number.isFinite(retryDelayMs) || retryDelayMs < 0) {
+        throw new Error(`[TriggerManager] retryDelayMs must be a non-negative number, got ${retryDelayMs}`);
+    }
+    if (options.timeoutMs != null) {
+        if (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 1) {
+            throw new Error(`[TriggerManager] timeoutMs must be a positive number when set, got ${options.timeoutMs}`);
+        }
+    }
+}
+
+function delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function invokeRunnerFn(
+    fn: TriggerRunnerFn,
+    ctx: TriggerRunnerContext,
+    timeoutMs: number | undefined,
+): Promise<void> {
+    if (timeoutMs == null) {
+        await fn(ctx);
+        return;
+    }
+
+    let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+    const timeoutPromise = new Promise<never>((_, reject) => {
+        timeoutHandle = setTimeout(() => {
+            reject(new Error(`Runner timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+
+    try {
+        await Promise.race([Promise.resolve(fn(ctx)), timeoutPromise]);
+    } finally {
+        if (timeoutHandle != null) {
+            clearTimeout(timeoutHandle);
+        }
+    }
+}
+
+/** In-process registry and tick loop for {@link TriggerNode}. */
+export const TriggerManager = {
+    registerRunner(options: RegisterTriggerRunnerOptions): void {
+        if (registrationClosed) {
+            throw new Error("[TriggerManager] Registration closed — call registerRunner before TriggerNode.start()");
+        }
+
+        const key = normalizeRunnerKey(options.key);
+        validateRunnerOptions(options);
+        if (typeof options.fn !== "function") {
+            throw new Error(`[TriggerManager] fn must be a function (runner key: ${key})`);
+        }
+        if (runnerRegistry.has(key)) {
+            throw new Error(`[TriggerManager] Duplicate runner key: ${key}`);
+        }
+
+        const now = Date.now();
+        runnerRegistry.set(key, {
+            key,
+            intervalMs: options.intervalMs,
+            fn: options.fn,
+            retryCount: options.retryCount ?? TRIGGER_RUNNER_DEFAULT_RETRY_COUNT,
+            retryDelayMs: options.retryDelayMs ?? TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS,
+            timeoutMs: options.timeoutMs,
+            nextRunAt: now + (options.initialDelayMs ?? 0),
+            running: false,
+        });
+    },
+
+    hasRunner(key: string): boolean {
+        const normalized = tryNormalizeRunnerKey(key);
+        return normalized != null && runnerRegistry.has(normalized);
+    },
+
+    unregisterRunner(key: string): boolean {
+        const normalized = tryNormalizeRunnerKey(key);
+        if (normalized == null) {
+            return false;
+        }
+        const runner = runnerRegistry.get(normalized);
+        if (runner == null) {
+            return false;
+        }
+        if (runner.running) {
+            throw new Error(`[TriggerManager] Cannot unregister running runner: ${normalized}`);
+        }
+        return runnerRegistry.delete(normalized);
+    },
+
+    getRunnerKeys(): string[] {
+        return [...runnerRegistry.keys()];
+    },
+
+    getRunnersBelowLoopInterval(): Array<{ key: string; intervalMs: number }> {
+        return [...runnerRegistry.values()]
+            .filter((runner) => runner.intervalMs < TRIGGER_LOOP_INTERVAL_MS)
+            .map((runner) => ({ key: runner.key, intervalMs: runner.intervalMs }));
+    },
+
+    /** Called by TriggerNode during bootstrap — blocks further registerRunner calls. */
+    closeRegistration(): void {
+        registrationClosed = true;
+    },
+
+    /** Re-open registration (tests only). */
+    _resetRegistrationForTests(): void {
+        registrationClosed = false;
+    },
+
+    /**
+     * Remove all runners. Throws if any runner is still executing.
+     * Wait for in-flight ticks to finish before calling in tests.
+     */
+    clearRunners(): void {
+        for (const runner of runnerRegistry.values()) {
+            if (runner.running) {
+                throw new Error(`[TriggerManager] Cannot clearRunners while runner is running: ${runner.key}`);
+            }
+        }
+        runnerRegistry.clear();
+        registrationClosed = false;
+    },
+
+    async tick(ctx: NodeLoopContext): Promise<void> {
+        const { loopTraceId, nodeId } = ctx;
+        const loopScope = createScope({ module: "tickRunners", traceId: loopTraceId, labels: { nodeId } });
+        const logger = createLogger({ scope: loopScope });
+
+        const now = Date.now();
+        const runners = [...runnerRegistry.values()];
+        if (runners.length === 0) {
+            logger.debug("無 runner 可調度", { topic: LOG_TOPIC_TRIGGER });
+            return;
+        }
+
+        // Overlap: if fn is still running when due, skip that tick (no catch-up / backlog).
+        // Safe while intervals are large; missed ticks increase if fn duration exceeds intervalMs.
+        const dueRunners = runners.filter((runner) => !runner.running && now >= runner.nextRunAt);
+        if (dueRunners.length === 0) {
+            logger.debug("本輪無到期 runner", { topic: LOG_TOPIC_TRIGGER });
+            return;
+        }
+
+        logger.debug("調度到期 runner", {
+            topic: LOG_TOPIC_TRIGGER,
+            data: { due: dueRunners.map((r) => r.key) },
+        });
+
+        const results = await Promise.all(dueRunners.map((runner) => runRunner(ctx, runner)));
+        const executed = results.filter(Boolean).length;
+        if (executed > 0) {
+            logger.info("Runner 調度完成", {
+                topic: LOG_TOPIC_TRIGGER,
+                data: { due: dueRunners.length, executed },
+            });
+        } else {
+            logger.warn("本輪到期 runner 均未成功", {
+                topic: LOG_TOPIC_TRIGGER,
+                data: {
+                    due: dueRunners.length,
+                    runnerKeys: dueRunners.map((r) => r.key),
+                },
+            });
+        }
+    },
+};
+
+async function runRunner(ctx: NodeLoopContext, runner: TriggerRunnerState): Promise<boolean> {
+    const { loopTraceId, nodeId } = ctx;
+    if (runner.running) {
+        return false;
+    }
+
+    runner.running = true;
+    const runnerLogger = createLogger({
+        scope: withModule(
+            createScope({ module: "runRunner", traceId: loopTraceId, labels: { nodeId, runnerKey: runner.key } }),
+            runner.key,
+        ),
+    });
+
+    const maxAttempts = 1 + runner.retryCount;
+    let succeeded = false;
+
+    try {
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                runnerLogger.info("Runner 觸發", {
+                    topic: LOG_TOPIC_TRIGGER,
+                    data: { attempt, maxAttempts },
+                });
+                await invokeRunnerFn(
+                    runner.fn,
+                    {
+                        loopTraceId,
+                        nodeId,
+                        runnerKey: runner.key,
+                        logger: runnerLogger,
+                        attempt,
+                        maxAttempts,
+                    },
+                    runner.timeoutMs,
+                );
+                runnerLogger.success("Runner 完成", {
+                    topic: LOG_TOPIC_TRIGGER,
+                    data: { attempt, maxAttempts },
+                });
+                succeeded = true;
+                break;
+            } catch (error) {
+                const message = getErrorMessage(error);
+                if (attempt < maxAttempts) {
+                    runnerLogger.warn("Runner 失敗，準備重試", {
+                        topic: LOG_TOPIC_TRIGGER,
+                        data: { attempt, maxAttempts, error: message },
+                    });
+                    if (runner.retryDelayMs > 0) {
+                        await delay(runner.retryDelayMs);
+                    }
+                } else {
+                    runnerLogger.error("Runner 重試用盡仍失敗", {
+                        topic: LOG_TOPIC_TRIGGER,
+                        data: { attempt, maxAttempts, error: message },
+                    });
+                }
+            }
+        }
+    } finally {
+        runner.running = false;
+        runner.nextRunAt = Date.now() + runner.intervalMs;
+    }
+
+    return succeeded;
+}

package/src/trigger/trigger-node.ts

@@ -0,0 +1,80 @@
+import { BaseNodeRuntime, LOG_TOPIC_NODE, type NodeLoopContext } from "../node/node-runtime.base";
+import { createLogger, createScope, type LoggerWithScope, LogLevel } from "../shared/log";
+import { LOG_TOPIC_TRIGGER, TRIGGER_LOOP_INTERVAL_MS } from "./trigger.constant";
+import type { TriggerNodeOptions } from "./trigger.interface";
+import { TriggerManager } from "./trigger-manager";
+
+/**
+ * Local interval scheduler node.
+ * Main loop: commands → heartbeat → {@link TriggerManager.tick}.
+ *
+ * Register runners via {@link TriggerManager.registerRunner} before {@link start}.
+ * Does not scan Supabase trigger rows — see `trigger.api.ts` for remote admin APIs.
+ *
+ * Deploy **one** TriggerNode per logical scheduler — multiple processes duplicate runner work.
+ */
+class TriggerNode extends BaseNodeRuntime {
+    private readonly requireRunners: boolean;
+
+    constructor(options?: TriggerNodeOptions) {
+        super("triggerNode");
+        this.requireRunners = options?.requireRunners ?? false;
+    }
+
+    protected getLoopIntervalMs(): number {
+        return TRIGGER_LOOP_INTERVAL_MS;
+    }
+
+    protected loopLoggerMinLevel(): LogLevel {
+        return LogLevel.WARN;
+    }
+
+    protected async onBeforeRegisterNode(logger: LoggerWithScope): Promise<void> {
+        TriggerManager.closeRegistration();
+
+        const runnerKeys = TriggerManager.getRunnerKeys();
+        if (runnerKeys.length === 0) {
+            if (this.requireRunners) {
+                throw new Error("[TriggerNode] requireRunners is true but no runners are registered");
+            }
+            logger.warn("未注册任何 Trigger runner，主循環將空轉", {
+                topic: LOG_TOPIC_TRIGGER,
+            });
+            return;
+        }
+
+        for (const { key, intervalMs } of TriggerManager.getRunnersBelowLoopInterval()) {
+            logger.warn("Runner interval 小於主循環 tick 間隔，實際觸發精度受限", {
+                topic: LOG_TOPIC_TRIGGER,
+                data: {
+                    runnerKey: key,
+                    intervalMs,
+                    loopIntervalMs: TRIGGER_LOOP_INTERVAL_MS,
+                },
+            });
+        }
+
+        logger.success("Trigger 節點啟動", {
+            topic: LOG_TOPIC_TRIGGER,
+            data: { runnerKeys },
+        });
+    }
+
+    protected async runLoopSteps(ctx: NodeLoopContext, heartbeatOk: boolean): Promise<void> {
+        if (!heartbeatOk) {
+            const logger = createLogger({
+                scope: createScope({
+                    module: `${this.runtimeModule}-runLoopSteps`,
+                    traceId: ctx.loopTraceId,
+                    labels: { nodeId: ctx.nodeId },
+                }),
+            });
+            logger.warn("心跳失敗，本輪跳過 runner", { topic: LOG_TOPIC_NODE });
+            return;
+        }
+        await TriggerManager.tick(ctx);
+    }
+}
+
+export type { TriggerNodeOptions } from "./trigger.interface";
+export { TriggerNode };

package/src/trigger/trigger.api.ts

@@ -1,14 +1,14 @@
+import { z } from "zod";
 import { createTarget, scanTargetList, updateTargetDetails, validateWithSchema } from "../core.api";
 import { generateResponse, type SupabaseResponse } from "../core.interface";
+import { createLogger } from "../shared/log";
 import { TaskStatus } from "../task/task.interface";
-import { createApiLogger } from "../shared/log";
-import { z } from "zod";
 import {
     CategoryTrigger,
-    Trigger,
-    TriggerStatus,
+    type Trigger,
     type TriggerAction,
     type TriggerSchedule,
+    TriggerStatus,
 } from "./trigger.interface";
 
 const TRIGGER_STATUS_FIELD = "details->>status" as const;
@@ -63,9 +63,9 @@ function enabledTriggerFilter() {
 /** List all ENABLED triggers (Phase 1: in-memory due check). */
 export const scanEnabledTriggers = validateWithSchema(
     scanEnabledTriggersSchema,
-    "scanEnabledTriggersSchema"
+    "scanEnabledTriggersSchema",
 )(async ({ traceId }) => {
-    const logger = createApiLogger("scanEnabledTriggers", { traceId });
+    const logger = createLogger({ module: "scanEnabledTriggers", traceId });
 
     try {
         const { data: triggerList } = await scanTargetList<Trigger>({
@@ -75,7 +75,7 @@ export const scanEnabledTriggers = validateWithSchema(
         });
 
         const rows = triggerList ?? [];
-        logger.info("已掃描 ENABLED Trigger", {
+        logger.debug("已掃描 ENABLED Trigger", {
             topic: "trigger",
             data: { count: rows.length },
         });
@@ -90,9 +90,9 @@ export const scanEnabledTriggers = validateWithSchema(
 /** Create a trigger row (scheduler / admin). */
 export const postTrigger = validateWithSchema(
     postTriggerSchema,
-    "postTriggerSchema"
+    "postTriggerSchema",
 )(async ({ name, value, status, schedule, action, tagList, traceId }) => {
-    const logger = createApiLogger("postTrigger", { traceId });
+    const logger = createLogger({ module: "postTrigger", traceId });
 
     const details = {
         manifestVersion: 0,
@@ -128,9 +128,9 @@ export const postTrigger = validateWithSchema(
  */
 export const patchTriggerFired = validateWithSchema(
     patchTriggerFiredSchema,
-    "patchTriggerFiredSchema"
+    "patchTriggerFiredSchema",
 )(async ({ triggerId, fireKey, expectedLastFireKey, traceId }) => {
-    const logger = createApiLogger("patchTriggerFired", { traceId });
+    const logger = createLogger({ module: "patchTriggerFired", traceId });
     const now = Date.now();
 
     try {

package/src/trigger/trigger.constant.ts

@@ -0,0 +1,10 @@
+export const LOG_TOPIC_TRIGGER = "trigger";
+
+/** Fixed main-loop interval for {@link TriggerNode} (ms). */
+export const TRIGGER_LOOP_INTERVAL_MS = 60_000;
+
+/** Default extra retries after first failure within one runner tick. */
+export const TRIGGER_RUNNER_DEFAULT_RETRY_COUNT = 3;
+
+/** Default delay between retry attempts within the same tick (ms). */
+export const TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS = 0;

package/src/trigger/trigger.interface.ts

@@ -1,5 +1,6 @@
-import { Target } from "../core.interface";
-import { TaskStatus } from "../task/task.interface";
+import type { Target } from "../core.interface";
+import type { LoggerWithScope } from "../shared/log";
+import type { TaskStatus } from "../task/task.interface";
 
 export enum CategoryTrigger {
     TRIGGER = "trigger",
@@ -48,3 +49,52 @@ export interface TriggerDetails {
     /** Idempotency key for the last successful fire, e.g. `daily:2026-06-18` (UTC date). */
     lastFireKey?: string | null;
 }
+
+// ─── TriggerNode local runners ───────────────────────────────────────────────
+
+/** Context passed to each runner invocation. */
+export interface TriggerRunnerContext {
+    loopTraceId: string;
+    nodeId: string;
+    runnerKey: string;
+    logger: LoggerWithScope;
+    /** 1-based attempt index within this tick (includes retries). */
+    attempt: number;
+    maxAttempts: number;
+}
+
+export type TriggerRunnerFn = (ctx: TriggerRunnerContext) => void | Promise<void>;
+
+export interface RegisterTriggerRunnerOptions {
+    /** Unique runner key within this process (trimmed; must be non-empty). */
+    key: string;
+    /** Minimum ms between tick starts for this runner. */
+    intervalMs: number;
+    fn: TriggerRunnerFn;
+    /** Delay first run after registration. Default `0`. */
+    initialDelayMs?: number;
+    /**
+     * Extra attempts after the first failure within the same tick.
+     * Default {@link TRIGGER_RUNNER_DEFAULT_RETRY_COUNT} from `./trigger.constant`.
+     */
+    retryCount?: number;
+    /**
+     * Delay between retry attempts within the same tick (ms).
+     * Default {@link TRIGGER_RUNNER_DEFAULT_RETRY_DELAY_MS} (`0` = immediate).
+     */
+    retryDelayMs?: number;
+    /**
+     * Max ms per fn invocation; rejects when exceeded.
+     * Does not cancel in-flight work — fn may still run after timeout. Omit for no limit.
+     */
+    timeoutMs?: number;
+}
+
+/** Options for {@link TriggerNode}. */
+export interface TriggerNodeOptions {
+    /**
+     * When true, bootstrap aborts if no runners were registered before `start()`.
+     * Default `false` (warn and idle loop).
+     */
+    requireRunners?: boolean;
+}

package/src/trigger/trigger.utils.ts

@@ -29,7 +29,7 @@ export function buildDailyFireKey(_schedule: TriggerDailySchedule, now: Date): s
 export function isDailyScheduleDue(
     schedule: TriggerDailySchedule,
     now: Date,
-    lastFireKey: string | null | undefined
+    lastFireKey: string | null | undefined,
 ): boolean {
     const parts = parseUtcDateParts(now);
     if (parts.hour !== schedule.hour || parts.minute !== schedule.minute) {

package/src/word/word.api.ts

@@ -1,43 +1,41 @@
 import { createTarget } from "../core.api";
 import { BaseValidator } from "../core.utils";
-import { Word, WordDetails } from "./word.interface";
+import type { Word, WordDetails } from "./word.interface";
 
 export interface PostWordPayload {
-  name: Word["name"];
-  value: Word["value"];
-  category: Word["category"];
-  details: WordDetails;
+    name: Word["name"];
+    value: Word["value"];
+    category: Word["category"];
+    details: WordDetails;
 }
 
 export class PostWordValidator extends BaseValidator<PostWordPayload> {
-  protected requiredFields: (keyof PostWordPayload)[] = ["name", "value", "category", "details"];
-  protected optionalFields: (keyof PostWordPayload)[] = [];
+    protected requiredFields: (keyof PostWordPayload)[] = ["name", "value", "category", "details"];
+    protected optionalFields: (keyof PostWordPayload)[] = [];
 
-  constructor() {
-    super();
-    // Add custom
-    this.addCustomValidator((val) => {
-      return true;
-    });
-  }
+    constructor() {
+        super();
+        // Add custom
+        this.addCustomValidator((_val) => {
+            return true;
+        });
+    }
 }
 
-
-
 export const postWord = async (payload: PostWordPayload) => {
-  return createTarget<Word, PostWordPayload>({
-    payload: payload,
-    validator: PostWordValidator,
-    createFn: (validPayload) => {
-      const { name, value, category, details } = validPayload;
+    return createTarget<Word, PostWordPayload>({
+        payload: payload,
+        validator: PostWordValidator,
+        createFn: (validPayload) => {
+            const { name, value, category, details } = validPayload;
 
-      return {
-        name,
-        category,
-        value,
-        tagList: [],
-        details,
-      };
-    },
-  });
+            return {
+                name,
+                category,
+                value,
+                tagList: [],
+                details,
+            };
+        },
+    });
 };

package/src/word/word.interface.ts

@@ -1,5 +1,5 @@
-import { Target } from "../core.interface";
-import { Link } from "../link/link.interface";
+import type { Target } from "../core.interface";
+import type { Link } from "../link/link.interface";
 
 export enum CategoryWord {
     WORD = "word",
@@ -19,5 +19,4 @@ export interface WordDetails {
     extensions: string[];
     scope: string;
     reviewList: Array<string | Link>;
-};
-
+}

package/dist/auth/auth.api.d.ts

@@ -1,28 +0,0 @@
-export interface LoginPayload {
-    email: string;
-    password: string;
-}
-export interface RegisterPayload {
-    email: string;
-    password: string;
-    confirmPassword?: string;
-}
-export interface User {
-    id: string;
-    email: string;
-    created_at: string;
-    last_sign_in_at?: string;
-}
-export declare const registerUser: ({ email, password }: RegisterPayload) => Promise<import("..").SupabaseResponse<{
-    user: import("@supabase/supabase-js").AuthUser | null;
-    session: import("@supabase/supabase-js").AuthSession | null;
-}>>;
-export declare const loginUser: ({ email, password }: LoginPayload) => Promise<import("..").SupabaseResponse<{
-    user: import("@supabase/supabase-js").AuthUser;
-    session: import("@supabase/supabase-js").AuthSession;
-    weakPassword?: import("@supabase/supabase-js").WeakPassword;
-}>>;
-export declare const logoutUser: () => Promise<import("..").SupabaseResponse<unknown>>;
-export declare const getCurrentUser: () => Promise<import("..").SupabaseResponse<User | null>>;
-export declare const resetPassword: (email: string) => Promise<import("..").SupabaseResponse<unknown>>;
-//# sourceMappingURL=auth.api.d.ts.map

package/dist/auth/auth.api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.api.d.ts","sourceRoot":"","sources":["../../src/auth/auth.api.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,IAAI;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAGD,eAAO,MAAM,YAAY,wBAA+B,eAAe;;;GAWtE,CAAC;AAGF,eAAO,MAAM,SAAS,wBAA+B,YAAY;;;;GAWhE,CAAC;AAGF,eAAO,MAAM,UAAU,uDAQtB,CAAC;AAGF,eAAO,MAAM,cAAc,2DAW1B,CAAC;AAGF,eAAO,MAAM,aAAa,UAAiB,MAAM,oDAQhD,CAAC"}

package/dist/auth/auth.api.js

@@ -1,51 +0,0 @@
-import { SupabaseInitializer } from "../supabase";
-import { generateResponse } from "../core.interface";
-import { handleSupabaseError } from "../core.utils";
-const supabase = SupabaseInitializer.getInstance();
-// 用户注册
-export const registerUser = async ({ email, password }) => {
-    const { data, error } = await supabase.authClient.auth.signUp({
-        email,
-        password,
-    });
-    if (error) {
-        handleSupabaseError("registerUser", error, "Registration failed. Please try again.");
-    }
-    return generateResponse.success(data);
-};
-// 用户登录
-export const loginUser = async ({ email, password }) => {
-    const { data, error } = await supabase.authClient.auth.signInWithPassword({
-        email,
-        password,
-    });
-    if (error) {
-        handleSupabaseError("loginUser", error, "Login failed. Please check your credentials.");
-    }
-    return generateResponse.success(data);
-};
-// 用户登出
-export const logoutUser = async () => {
-    const { error } = await supabase.authClient.auth.signOut();
-    if (error) {
-        handleSupabaseError("logoutUser", error, "Logout failed.");
-    }
-    return generateResponse.success();
-};
-// 获取当前用户
-export const getCurrentUser = async () => {
-    const { data: { user }, error, } = await supabase.authClient.auth.getUser();
-    if (error) {
-        handleSupabaseError("getCurrentUser", error, "Failed to get current user.");
-    }
-    return generateResponse.success(user);
-};
-// 重置密码
-export const resetPassword = async (email) => {
-    const { error } = await supabase.authClient.auth.resetPasswordForEmail(email);
-    if (error) {
-        handleSupabaseError("resetPassword", error, "Password reset request failed.");
-    }
-    return generateResponse.success();
-};
-//# sourceMappingURL=auth.api.js.map