target-supabase-sdk 0.1.9 → 0.2.1

package/dist/chunks/create-logger-DyH3mZ8p.js

@@ -0,0 +1,1028 @@
+import { createClient } from '@supabase/supabase-js';
+import { pick, pickBy } from 'lodash-es';
+
+var StatusCode;
+(function (StatusCode) {
+    StatusCode[StatusCode["SUCCESS"] = 200] = "SUCCESS";
+    StatusCode[StatusCode["ERROR"] = 400] = "ERROR";
+})(StatusCode || (StatusCode = {}));
+const generateResponse = {
+    success(data, message) {
+        return {
+            status_code: StatusCode.SUCCESS,
+            success: true,
+            message,
+            data,
+        };
+    },
+    error(message, statusCode, code) {
+        if (typeof message === "string") {
+            return {
+                status_code: statusCode ?? StatusCode.ERROR,
+                success: false,
+                error: {
+                    message,
+                    code,
+                },
+            };
+        }
+        if (typeof message?.error === "string") {
+            return {
+                status_code: statusCode ?? StatusCode.ERROR,
+                success: false,
+                error: {
+                    message: `Error from ${message.key}: ${message.error}`,
+                    code,
+                },
+            };
+        }
+        return {
+            status_code: statusCode ?? StatusCode.ERROR,
+            success: false,
+            error: {
+                message: `Error from ${message.key}: ${message?.error?.message}`,
+                code,
+            },
+        };
+    },
+};
+
+/** True when running in a development build (Vite or Node). Defaults to false for safety. */
+function isDevEnvironment() {
+    if (typeof import.meta !== "undefined" && "env" in import.meta) {
+        const env = import.meta.env;
+        if (env?.DEV === true || env?.MODE === "development")
+            return true;
+        if (env?.DEV === false || env?.MODE === "production")
+            return false;
+    }
+    if (typeof process !== "undefined" && process.env?.NODE_ENV) {
+        return process.env.NODE_ENV !== "production";
+    }
+    return false;
+}
+function logDev(...args) {
+    if (isDevEnvironment()) {
+        console.log(...args);
+    }
+}
+function logDevGroup(label, fn) {
+    if (!isDevEnvironment())
+        return;
+    console.group(label);
+    try {
+        fn();
+    }
+    finally {
+        console.groupEnd();
+    }
+}
+/** Log internal details, then throw a sanitized error safe to expose to callers. */
+function handleSupabaseError(context, error, publicMessage) {
+    console.error(`[${context}] failed:`, error);
+    throw new Error(publicMessage ?? `[${context}] Operation failed`);
+}
+/** Raw payload -> Available data */
+class BaseValidator {
+    requiredFields = [];
+    optionalFields = [];
+    ignoredFields = [];
+    customValidators = [];
+    addCustomValidator(validator) {
+        this.customValidators.push(validator);
+        return this;
+    }
+    validateField(_field, value) {
+        // TODO now only empty check, later should add type checks
+        return value != null;
+    }
+    validate = (val) => {
+        const errors = [];
+        // Step 1: Check required fields
+        this.requiredFields.forEach((field) => {
+            if (!this.validateField(field, val[field])) {
+                errors.push(`Missing required field: ${String(field)}`);
+            }
+        });
+        // Step 2: Run custom validators
+        this.customValidators.forEach((validator) => {
+            const result = validator(val);
+            if (result !== true) {
+                errors.push(`Custom validation failed ${result}`);
+            }
+        });
+        if (errors.length > 0) {
+            const errorCount = errors.length;
+            const errorList = errors.map((error, index) => `  ${index + 1}. ${error}`).join("\n");
+            throw new Error(`[${this.constructor.name}] Validation failed (${errorCount} error${errorCount > 1 ? "s" : ""}):\n${errorList}`);
+        }
+        // Step 3: Pick required and optional fields
+        const required = pick(val, this.requiredFields);
+        const optional = pickBy(val, (value, key) => {
+            const typedKey = key;
+            return this.optionalFields.includes(typedKey) && value != null;
+        });
+        // TODO ignoredFields
+        return { ...required, ...optional };
+    };
+}
+
+class SupabaseInitializer {
+    static instance;
+    isInitialized = false;
+    _mainClient = null;
+    _authClient = null;
+    constructor() { }
+    static getInstance() {
+        if (!SupabaseInitializer.instance) {
+            SupabaseInitializer.instance = new SupabaseInitializer();
+        }
+        return SupabaseInitializer.instance;
+    }
+    /**
+     * Initialize Supabase clients
+     */
+    async initialize(params) {
+        if (this.isInitialized) {
+            logDev("🚫 Supabase already initialized");
+            return { supabase: this._mainClient, supabaseAuth: this._authClient };
+        }
+        logDev("🔧 Initializing Supabase...");
+        // Validate and get environment variables
+        const config = this.validateEnvironmentVariables(params);
+        // Create main client
+        this._mainClient = createClient(config.main.url, config.main.anonKey, {
+        // TODO
+        // auth: {
+        //   persistSession: true,
+        //   autoRefreshToken: true,
+        // },
+        });
+        // Create auth client if configured
+        if (config.auth) {
+            this._authClient = createClient(config.auth.url, config.auth.anonKey, {
+            // TODO
+            // auth: {
+            //   persistSession: true,
+            //   autoRefreshToken: true,
+            // },
+            });
+        }
+        // Log configuration
+        this.logConfiguration(config);
+        this.isInitialized = true;
+        logDev("✅ Supabase initialization completed");
+        return { supabase: this._mainClient, supabaseAuth: this._authClient };
+    }
+    validateEnvironmentVariables({ supabaseUrl, supabaseAnonKey, supabaseNeedAuthUrl, supabaseNeedAuthAnonKey, }) {
+        const mainUrl = supabaseUrl;
+        const mainAnonKey = supabaseAnonKey;
+        const authUrl = supabaseNeedAuthUrl;
+        const authAnonKey = supabaseNeedAuthAnonKey;
+        if (!mainUrl || !mainAnonKey) {
+            throw new Error("Missing required Supabase environment variables: SUPABASE_URL, SUPABASE_ANON_KEY");
+        }
+        return {
+            main: { url: mainUrl, anonKey: mainAnonKey },
+            auth: authUrl && authAnonKey ? { url: authUrl, anonKey: authAnonKey } : null,
+        };
+    }
+    logConfiguration(config) {
+        logDevGroup("🔧 Supabase Configuration", () => {
+            console.log("Main URL:", config.main.url);
+            console.log("Auth URL:", config.auth?.url || "Not configured");
+            console.log("Clients:", {
+                main: !!this._mainClient,
+                auth: !!this._authClient,
+            });
+        });
+    }
+    getClients() {
+        if (!this.isInitialized) {
+            throw new Error("Supabase not initialized. Call initialize() first.");
+        }
+        return { supabase: this._mainClient, supabaseAuth: this._authClient };
+    }
+    get client() {
+        if (!this.isInitialized) {
+            throw new Error("Supabase not initialized. Call initialize() first.");
+        }
+        if (!this._mainClient) {
+            throw new Error("Main Supabase client is null. Initialization may have failed.");
+        }
+        return this._mainClient;
+    }
+    get authClient() {
+        if (!this.isInitialized) {
+            throw new Error("Supabase not initialized. Call initialize() first.");
+        }
+        return this._authClient;
+    }
+    reset() {
+        this.isInitialized = false;
+        this._mainClient = null;
+        this._authClient = null;
+    }
+}
+/** Process-wide holder — import this; class is module-private. */
+const supabase = SupabaseInitializer.getInstance();
+
+const MAX_TARGET_LIST_PAGE_SIZE = 100;
+/** Alias for {@link pollTargetList} batch size cap. */
+const MAX_POLL_TARGET_LIST_SIZE = MAX_TARGET_LIST_PAGE_SIZE;
+const TARGET_LIST_ORDER_FIELDS = new Set(["created_at", "name", "value", "category"]);
+function validateTargetListPagination(pageNum, pageSize) {
+    if (!Number.isInteger(pageNum) || pageNum < 0) {
+        throw new Error(`[getTargetList] pageNum must be a non-negative integer, got ${pageNum}`);
+    }
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > MAX_TARGET_LIST_PAGE_SIZE) {
+        throw new Error(`[getTargetList] pageSize must be an integer between 1 and ${MAX_TARGET_LIST_PAGE_SIZE}, got ${pageSize}`);
+    }
+}
+function resolveTargetListPagination(params) {
+    if (params.limit != null) {
+        validateTargetListPagination(0, params.limit);
+        return { pageNum: 0, pageSize: params.limit };
+    }
+    if (params.pageNum === undefined || params.pageSize === undefined) {
+        throw new Error("[getTargetList] Provide pageNum and pageSize, or limit.");
+    }
+    validateTargetListPagination(params.pageNum, params.pageSize);
+    return { pageNum: params.pageNum, pageSize: params.pageSize };
+}
+function validateTargetListOrderBy(orderBy) {
+    if (!TARGET_LIST_ORDER_FIELDS.has(orderBy.field)) {
+        throw new Error(`[getTargetList] Unsupported orderBy.field "${orderBy.field}"; allowed: ${[...TARGET_LIST_ORDER_FIELDS].join(", ")}`);
+    }
+}
+/**
+ * 构建带 category 作用域的 target 查询（供 getTargetList / getTargetTotalCount / pollTargetList 共用）。
+ *
+ * 必要性：
+ * 1. category 是 target 表的分区维度，所有列表/计数/出队都必须限定 category，避免跨类型扫表。
+ * 2. 传入 filterBuilder 时仍强制 `.eq("category", category)`，防止自定义 builder 漏加 category 导致误查或安全问题。
+ * 3. 统一 select 普通列表与 count head 两种查询形态，再叠加 filterList，避免三处复制分支逻辑。
+ */
+function buildCategoryScopedQuery({ category, filterList, filterBuilder, select, selectOptions, }) {
+    const base = filterBuilder != null
+        ? filterBuilder.eq("category", category)
+        : selectOptions != null
+            ? supabase.client.from("target").select(select, selectOptions).eq("category", category)
+            : supabase.client.from("target").select(select).eq("category", category);
+    return applyQueryFilters(base, filterList);
+}
+// biome-ignore lint/suspicious/noExplicitAny: PostgrestFilterBuilder is generic over schema
+function applyQueryFilter(query, filter) {
+    switch (filter.operator) {
+        case "eq":
+            return query.eq(filter.field, filter.value);
+        case "neq":
+            return query.neq(filter.field, filter.value);
+        case "in":
+            return query.in(filter.field, filter.value);
+        default: {
+            const unsupportedOperator = filter.operator;
+            throw new Error(`[applyQueryFilter] Unsupported operator: ${unsupportedOperator}`);
+        }
+    }
+}
+// biome-ignore lint/suspicious/noExplicitAny: PostgrestFilterBuilder is generic over schema
+function applyQueryFilters(query, filterList) {
+    return filterList.reduce((q, filter) => applyQueryFilter(q, filter), query);
+}
+const getTarget = async ({ id, filterList }) => {
+    const query = filterList != null && filterList.length > 0
+        ? applyQueryFilters(supabase.client.from("target").select().eq("id", id), filterList)
+        : supabase.client.from("target").select().eq("id", id);
+    const { data, error } = await query.single();
+    if (error) {
+        handleSupabaseError("getTarget", error, "Failed to fetch target.");
+    }
+    return generateResponse.success(data);
+};
+const getPossibleTarget = async ({ filterList }) => {
+    const query = applyQueryFilters(supabase.client.from("target").select(), filterList);
+    const { data, error } = await query.maybeSingle();
+    if (error) {
+        handleSupabaseError("getPossibleTarget", error, "Failed to fetch target.");
+    }
+    return generateResponse.success(data);
+};
+/**
+ * Paginated target list by category. Failures throw via `handleSupabaseError` (no `{ error }` envelope).
+ */
+const getTargetList = async ({ pageNum, pageSize, limit, category, filterList = [], orderBy = { field: "created_at", ascending: false }, selectFields = "*", filterBuilder, }) => {
+    const { pageNum: resolvedPageNum, pageSize: resolvedPageSize } = resolveTargetListPagination({
+        pageNum,
+        pageSize,
+        limit,
+    });
+    validateTargetListOrderBy(orderBy);
+    const query = buildCategoryScopedQuery({
+        category,
+        filterList,
+        filterBuilder,
+        select: selectFields,
+    });
+    const { data, error } = await query
+        .order(orderBy.field, { ascending: orderBy.ascending })
+        .range(resolvedPageNum * resolvedPageSize, (resolvedPageNum + 1) * resolvedPageSize - 1);
+    if (error) {
+        handleSupabaseError("getTargetList", error, "Failed to fetch target list.");
+    }
+    return generateResponse.success((data ?? []));
+};
+/**
+ * Scan all rows matching `category` + `filterList` by paging until exhausted.
+ *
+ * Use for worker bootstrap / sync jobs that need the full matching set.
+ * For UI pagination, use {@link getTargetList} (single page, explicit pageNum).
+ *
+ * Internal batch size is fixed at {@link MAX_TARGET_LIST_PAGE_SIZE} (PostgREST max-rows).
+ * Callers receive the full merged result; they do not pass a per-request page size.
+ *
+ * Uses offset pagination (`.range`). Stable enough for small catalogs (e.g. Repo registry);
+ * for large tables under concurrent writes, consider a DB RPC or keyset pagination later.
+ */
+const scanTargetList = async ({ category, filterList = [], orderBy = { field: "created_at", ascending: false }, selectFields = "*", filterBuilder, maxRows, }) => {
+    const batchSize = MAX_TARGET_LIST_PAGE_SIZE;
+    validateTargetListOrderBy(orderBy);
+    if (maxRows != null && (!Number.isInteger(maxRows) || maxRows < 1)) {
+        throw new Error(`[scanTargetList] maxRows must be a positive integer, got ${maxRows}`);
+    }
+    const rows = [];
+    let pageNum = 0;
+    while (true) {
+        const query = buildCategoryScopedQuery({
+            category,
+            filterList,
+            filterBuilder,
+            select: selectFields,
+        });
+        const { data, error } = await query
+            .order(orderBy.field, { ascending: orderBy.ascending })
+            .range(pageNum * batchSize, (pageNum + 1) * batchSize - 1);
+        if (error) {
+            handleSupabaseError("scanTargetList", error, "Failed to scan target list.");
+        }
+        const page = (data ?? []);
+        if (page.length === 0) {
+            break;
+        }
+        rows.push(...page);
+        if (maxRows != null && rows.length >= maxRows) {
+            rows.length = maxRows;
+            break;
+        }
+        if (page.length < batchSize) {
+            break;
+        }
+        pageNum += 1;
+    }
+    return generateResponse.success(rows);
+};
+const getTargetTotalCount = async ({ category, filterList = [], filterBuilder }) => {
+    const query = buildCategoryScopedQuery({
+        category,
+        filterList,
+        filterBuilder,
+        select: "id",
+        selectOptions: { count: "exact", head: true },
+    });
+    const { count, error } = await query;
+    if (error) {
+        handleSupabaseError("getTargetTotalCount", error, "Failed to fetch target count.");
+    }
+    return generateResponse.success(count ?? 0);
+};
+function validatePollTargetListSize(size) {
+    if (!Number.isInteger(size) || size < 1 || size > MAX_POLL_TARGET_LIST_SIZE) {
+        throw new Error(`[pollTargetList] size must be an integer between 1 and ${MAX_POLL_TARGET_LIST_SIZE}, got ${size}`);
+    }
+}
+/**
+ * Queue poll: SELECT up to `size` rows matching `category` + `filterList`, ordered by
+ * `created_at`, then DELETE each by `id`. Returns only dequeued rows (at-most-once).
+ *
+ * Delete failures (concurrent consumer) are skipped silently.
+ * Failures on the initial SELECT throw via `handleSupabaseError`.
+ *
+ * TODO(concurrency): 当前为 SELECT → 逐条 DELETE，非 DB 原子出队，多 consumer 并发时可能：
+ * - 重叠读取：两个 worker 同一批 SELECT 命中相同行，靠 DELETE 竞速，后者 skip（多数 at-most-once）
+ * - TOCTOU：SELECT 与 DELETE 之间无锁，极端情况下 DELETE 0 行仍不报错 → 可能重复计入 polled
+ * - 非 exactly-once：行已删但 worker 崩溃未处理 → 消息丢失
+ * 若同一 filter 多实例 poll（或多 worker 同 nodeId），需改为 DB 侧原子方案，例如：
+ * - RPC：`DELETE … WHERE id IN (SELECT … FOR UPDATE SKIP LOCKED) RETURNING *`
+ * - 或 claim 状态机：UPDATE … WHERE pending → DELETE/标记已消费（类似 patchClaimTask 乐观锁）
+ * - 短期加固：DELETE 后校验影响行数，0 行则不 push 到 polled
+ */
+const pollTargetList = async ({ category, size, filterList = [], ascending = true, selectFields = "*", }) => {
+    validatePollTargetListSize(size);
+    const query = buildCategoryScopedQuery({
+        category,
+        filterList,
+        select: selectFields,
+    });
+    const { data, error } = await query.order("created_at", { ascending }).limit(size);
+    if (error) {
+        handleSupabaseError("pollTargetList", error, "Failed to fetch targets for poll.");
+    }
+    const candidates = (data ?? []);
+    const polled = [];
+    for (const row of candidates) {
+        try {
+            await deleteTarget({ id: row.id });
+            polled.push(row);
+        }
+        catch {
+            // Concurrent dequeue — row already removed
+        }
+    }
+    return generateResponse.success(polled);
+};
+const deleteTarget = async ({ id, filterList }) => {
+    // Check whether the target exists given filterList
+    if (filterList != null && filterList.length > 0) {
+        const query = applyQueryFilters(supabase.client.from("target").select().eq("id", id), filterList);
+        const { data: existingTarget, error: existingError } = await query.single();
+        if (existingError || existingTarget == null) {
+            const msg = `[deleteTarget] Cannot find the target ${id}`;
+            console.error(msg, { filterList }, existingError);
+            throw new Error(msg);
+        }
+    }
+    const { error } = await supabase.client.from("target").delete().eq("id", id);
+    if (error) {
+        handleSupabaseError("deleteTarget", error, `Failed to delete target ${id}.`);
+    }
+    return generateResponse.success();
+};
+class PostTargetPayloadValidator extends BaseValidator {
+    requiredFields = ["category", "name", "value", "tagList"];
+    optionalFields = ["extra", "details"];
+    constructor() {
+        super();
+        // Add custom
+        this.addCustomValidator((_val) => {
+            return true;
+        });
+    }
+}
+const postTarget = async (payload) => {
+    const validPayload = new PostTargetPayloadValidator().validate(payload);
+    const { data, error } = await supabase.client
+        .from("target")
+        .insert([{ ...validPayload }])
+        .select()
+        .single();
+    if (error) {
+        handleSupabaseError("postTarget", error, "Failed to create target.");
+    }
+    return generateResponse.success(data);
+};
+const patchTarget = async ({ id, ...restPayload }) => {
+    const { data: currentData, error: fetchError } = await supabase.client
+        .from("target")
+        .select()
+        .eq("id", id)
+        .single();
+    if (!currentData) {
+        throw new Error("Target NOT exists");
+    }
+    if (fetchError)
+        handleSupabaseError("patchTarget", fetchError, "Failed to fetch target.");
+    const updatedTarget = new PostTargetPayloadValidator().validate(restPayload);
+    const { data, error } = await supabase.client
+        .from("target")
+        .update({
+        ...updatedTarget,
+    })
+        .eq("id", id)
+        .select()
+        .single();
+    if (error) {
+        handleSupabaseError("patchTarget", error, "Failed to update target.");
+    }
+    return generateResponse.success(data);
+};
+const updateTargetDetails = async ({ id, updateFn, updateExtraFn, optimisticLockFilterList = [], }) => {
+    const { data: currentData, error: fetchError } = await supabase.client
+        .from("target")
+        .select("details")
+        .eq("id", id)
+        .single();
+    if (fetchError) {
+        handleSupabaseError("updateTargetDetails", fetchError, "Failed to fetch target.");
+    }
+    if (!currentData) {
+        const msg = `[updateTargetDetails] Target NOT exists: ${id}`;
+        console.error(msg);
+        throw new Error(msg);
+    }
+    const currentDetails = currentData.details;
+    const updatedDetails = updateFn(currentDetails);
+    const updated = updateExtraFn == null
+        ? {
+            details: updatedDetails,
+        }
+        : {
+            details: updatedDetails,
+            extra: updateExtraFn(currentDetails),
+        };
+    const updateQuery = applyQueryFilters(supabase.client.from("target").update(updated).eq("id", id), optimisticLockFilterList);
+    const { data, error } = await updateQuery.select().maybeSingle();
+    if (error) {
+        handleSupabaseError("updateTargetDetails", error, "Failed to update target details.");
+    }
+    if (!data) {
+        const msg = optimisticLockFilterList.length > 0
+            ? OPTIMISTIC_LOCK_FAILED_MESSAGE
+            : "[updateTargetDetails] Target not found or was deleted.";
+        throw new Error(msg);
+    }
+    return data;
+};
+const OPTIMISTIC_LOCK_FAILED_MESSAGE = "[updateTargetDetails] Optimistic lock failed: target no longer matches expected state.";
+const OPTIMISTIC_LOCK_ERROR_CODE = "OPTIMISTIC_LOCK";
+function isOptimisticLockError(error) {
+    return error instanceof Error && error.message === OPTIMISTIC_LOCK_FAILED_MESSAGE;
+}
+function isOptimisticLockResponse(error) {
+    return error?.code === OPTIMISTIC_LOCK_ERROR_CODE;
+}
+const CREATE_TARGET_ALREADY_EXISTS_MESSAGE = "[createTarget] Target already exists";
+const CREATE_TARGET_REDUNDANCY_MISMATCH_MESSAGE = "[createTarget] Inserted row does not match checkRedundancyFilterList; verify createFn aligns with filters.";
+/** Max rows to fetch during post-verify — only need to detect one other match. */
+const REDUNDANCY_VERIFY_ROW_LIMIT = 2;
+function isCreateTargetAlreadyExistsError(error) {
+    return error instanceof Error && error.message === CREATE_TARGET_ALREADY_EXISTS_MESSAGE;
+}
+/** Roll back an optimistic insert when redundancy filters match other rows. */
+async function rollbackCreateTargetInsert(id) {
+    const { error } = await supabase.client.from("target").delete().eq("id", id);
+    if (error) {
+        handleSupabaseError("createTarget", error, "Failed to rollback conflicting insert.");
+    }
+}
+/** Roll back the new row and signal a redundancy conflict to the caller. */
+function throwCreateTargetAlreadyExists(checkRedundancyFilterList) {
+    console.error(CREATE_TARGET_ALREADY_EXISTS_MESSAGE, checkRedundancyFilterList);
+    throw new Error(CREATE_TARGET_ALREADY_EXISTS_MESSAGE);
+}
+async function failCreateTargetRedundancy(selfId, checkRedundancyFilterList) {
+    await rollbackCreateTargetInsert(selfId);
+    return throwCreateTargetAlreadyExists(checkRedundancyFilterList);
+}
+/**
+ * Create a `target` row with optional payload validation and optimistic redundancy checks.
+ *
+ * When `checkRedundancyFilterList` is set, uses insert-first + post-verify (not SELECT-before-INSERT).
+ * See `.cursor/skills/create-target-redundancy/SKILL.md`.
+ */
+const createTarget = async ({ payload, validator, createFn, checkRedundancyFilterList, upsert = false, }) => {
+    if (upsert) {
+        console.warn("[createTarget] `upsert` is deprecated and has no effect.");
+    }
+    const validPayload = validator != null ? new validator().validate(payload) : payload;
+    const newTarget = createFn(validPayload);
+    const hasRedundancyCheck = checkRedundancyFilterList != null && checkRedundancyFilterList.length > 0;
+    // 1. Optimistic insert (see create-target-redundancy skill)
+    const { data, error } = await supabase.client.from("target").insert([newTarget]).select().single();
+    if (error) {
+        handleSupabaseError("createTarget", error, "Failed to create target.");
+    }
+    if (!hasRedundancyCheck) {
+        return generateResponse.success(data);
+    }
+    // 2. Post-verify: limit(2) — enough to detect one other row matching the business-key filters
+    const { data: matches, error: matchError } = await applyQueryFilters(supabase.client.from("target").select("id"), checkRedundancyFilterList).limit(REDUNDANCY_VERIFY_ROW_LIMIT);
+    if (matchError) {
+        handleSupabaseError("createTarget", matchError, "Failed to verify target redundancy.");
+    }
+    const selfId = data.id;
+    const rows = matches ?? [];
+    const selfMatchesFilters = rows.some((row) => row.id === selfId);
+    if (!selfMatchesFilters) {
+        console.warn(CREATE_TARGET_REDUNDANCY_MISMATCH_MESSAGE, checkRedundancyFilterList);
+    }
+    const hasOtherRow = rows.some((row) => row.id !== selfId);
+    // 3. No conflict — keep the inserted row; otherwise rollback and reject
+    if (!hasOtherRow) {
+        return generateResponse.success(data);
+    }
+    return failCreateTargetRedundancy(selfId, checkRedundancyFilterList);
+};
+function validateWith(ValidatorClass) {
+    return (fn) => {
+        return (payload) => {
+            const validPayload = new ValidatorClass().validate(payload);
+            return fn(validPayload);
+        };
+    };
+}
+function formatZodValidationError(schemaName, error) {
+    const errorList = error.issues
+        .map((issue, index) => {
+        const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `  ${index + 1}. ${path}: ${issue.message}`;
+    })
+        .join("\n");
+    const errorCount = error.issues.length;
+    return new Error(`[${schemaName}] Validation failed (${errorCount} error${errorCount > 1 ? "s" : ""}):\n${errorList}`);
+}
+/** Zod-based counterpart to {@link validateWith} — requires `zod` as a peer dependency. */
+function validateWithSchema(schema, schemaName = "Schema") {
+    return (fn) => {
+        return (payload) => {
+            const result = schema.safeParse(payload);
+            if (!result.success) {
+                throw formatZodValidationError(schemaName, result.error);
+            }
+            return fn(result.data);
+        };
+    };
+}
+
+var CategoryList;
+(function (CategoryList) {
+    CategoryList["LIST"] = "list";
+})(CategoryList || (CategoryList = {}));
+
+class PostListValidator extends BaseValidator {
+    requiredFields = ["name", "value", "category", "details"];
+    optionalFields = [];
+    constructor() {
+        super();
+        // Add custom
+        this.addCustomValidator((_val) => {
+            return true;
+        });
+    }
+}
+const postListCreate = async (payload) => {
+    return createTarget({
+        payload: payload,
+        validator: PostListValidator,
+        createFn: (validPayload) => {
+            const { name, value, category, details } = validPayload;
+            return {
+                name,
+                category,
+                value,
+                tagList: [],
+                details,
+            };
+        },
+    });
+};
+/** Log batch create — idempotent on List.value (stable batch hash). */
+const postLogListCreate = async (payload) => {
+    return createTarget({
+        payload,
+        validator: PostListValidator,
+        checkRedundancyFilterList: [
+            { field: "category", operator: "eq", value: CategoryList.LIST },
+            { field: "value", operator: "eq", value: payload.value },
+        ],
+        createFn: (validPayload) => {
+            const { name, value, category, details } = validPayload;
+            return {
+                name,
+                category,
+                value,
+                tagList: [],
+                details,
+            };
+        },
+    });
+};
+
+/** RFC 4122 v4 UUID for trace / correlation ids. Requires Node 18+ (`engines` in package.json). */
+function generateUniqueId() {
+    return globalThis.crypto.randomUUID();
+}
+
+let offerFn = null;
+function registerLogPersistOffer(fn) {
+    offerFn = fn;
+}
+function offerToLogPersist(entry) {
+    offerFn?.(entry);
+}
+
+function mergeLabels(base, patch) {
+    const merged = { ...base, ...patch };
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+/** Coerce partial input into a {@link LogScope}. */
+function normalizeScope(input, options) {
+    const generateTraceId = false;
+    const traceId = input.traceId?.trim() || (generateTraceId ? generateUniqueId() : "");
+    if (!traceId) {
+        throw new Error("[LogScope] traceId is required (or enable generateTraceId)");
+    }
+    return {
+        module: input.module,
+        traceId,
+        traceParentId: input.traceParentId ?? null,
+        labels: mergeLabels(undefined, input.labels),
+    };
+}
+/** Build a scope; optional parent links trace chain and merges labels. */
+function createScope(input) {
+    const { module, parent, traceId, traceParentId, labels } = input;
+    return normalizeScope({
+        module,
+        traceId,
+        traceParentId: traceParentId ?? (parent != null ? parent.traceId : null),
+        labels: parent != null ? mergeLabels(parent.labels, labels) : mergeLabels(undefined, labels),
+    });
+}
+/** Merge patch into scope (labels deep-merge). Returns a new scope. */
+function patchScope(input) {
+    const { scope, patch, allowTraceMutation = false } = input;
+    const traceId = allowTraceMutation && patch.traceId != null && patch.traceId !== "" ? patch.traceId : scope.traceId;
+    const traceParentId = allowTraceMutation && patch.traceParentId !== undefined ? patch.traceParentId : scope.traceParentId;
+    return normalizeScope({
+        module: patch.module ?? scope.module,
+        traceId,
+        traceParentId,
+        labels: mergeLabels(scope.labels, patch.labels),
+    });
+}
+/** Same trace chain, different module (e.g. prepareTask vs executeTask). */
+function withModule(scope, module) {
+    return patchScope({ scope, patch: { module } });
+}
+function formatScopeLabels(labels) {
+    if (labels == null || Object.keys(labels).length === 0) {
+        return "--";
+    }
+    return Object.entries(labels)
+        .map(([key, value]) => `${key}:${value}`)
+        .join(",");
+}
+/** Prefer `data`; fall back to deprecated `context` on log rest params. */
+function resolveLogData(rest) {
+    if (rest?.data !== undefined) {
+        return rest.data;
+    }
+    if (rest?.context !== undefined) {
+        return rest.context;
+    }
+    return undefined;
+}
+
+/**
+ * Log severity and semantics (low → high). `minLevel` filters by {@link LOG_LEVEL_RANK}.
+ *
+ * | Level    | Rank | When to use |
+ * |----------|------|-------------|
+ * | DEBUG    | 0    | Diagnostic detail for dev/troubleshooting; noisy, safe to drop in prod. |
+ * | INFO     | 1    | Normal operational flow (startup, polling, state transitions). |
+ * | SUCCESS  | 2    | Positive milestone within a flow (not a separate severity axis — same band as INFO). |
+ * | WARN     | 3    | Recoverable anomaly or degradation; work continues but worth watching. |
+ * | ERROR    | 4    | A concrete operation failed (API, task step, I/O); investigate and retry/fix locally. |
+ * | CRITICAL | 5    | Invariant violated — design flaw, data-integrity risk, or business rule broken; escalate and fix urgently. |
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "DEBUG";
+    LogLevel["INFO"] = "INFO";
+    LogLevel["SUCCESS"] = "SUCCESS";
+    LogLevel["WARN"] = "WARN";
+    LogLevel["ERROR"] = "ERROR";
+    LogLevel["CRITICAL"] = "CRITICAL";
+})(LogLevel || (LogLevel = {}));
+const LOG_LEVEL_RANK = {
+    [LogLevel.DEBUG]: 0,
+    [LogLevel.INFO]: 1,
+    [LogLevel.SUCCESS]: 2,
+    [LogLevel.WARN]: 3,
+    [LogLevel.ERROR]: 4,
+    [LogLevel.CRITICAL]: 5,
+};
+const DEFAULT_OPTIONS = {
+    formatTimestamp: true,
+    formatEmoji: true,
+    formatPrefix: "",
+    minLevel: isDevEnvironment() ? LogLevel.DEBUG : LogLevel.INFO,
+};
+function mergeLogOptions(options) {
+    return { ...DEFAULT_OPTIONS, ...options };
+}
+function formatDataValue(value) {
+    if (value === undefined) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function validateLogScope(logScope) {
+    const missing = [];
+    if (!logScope.module?.trim()) {
+        missing.push("module");
+    }
+    if (!logScope.traceId?.trim()) {
+        missing.push("traceId");
+    }
+    if (logScope.traceParentId !== null && typeof logScope.traceParentId !== "string") {
+        missing.push("traceParentId");
+    }
+    if (missing.length > 0) {
+        console.warn(`[LogManager] LogScope missing or invalid: ${missing.join(", ")}`, logScope);
+    }
+}
+class LogManager {
+    static instance;
+    options;
+    levelEmojis = {
+        [LogLevel.DEBUG]: "🔍",
+        [LogLevel.INFO]: "ℹ️",
+        [LogLevel.SUCCESS]: "✅",
+        [LogLevel.WARN]: "⚠️",
+        [LogLevel.ERROR]: "❌",
+        [LogLevel.CRITICAL]: "💀",
+    };
+    constructor(options) {
+        this.options = mergeLogOptions(options);
+    }
+    static getInstance(options) {
+        if (!LogManager.instance) {
+            LogManager.instance = new LogManager(options);
+        }
+        else if (options != null && Object.keys(options).length > 0) {
+            console.warn("[LogManager] getInstance(options) ignored — singleton already created. Use setOptions() instead.");
+        }
+        return LogManager.instance;
+    }
+    setOptions(options) {
+        this.options = mergeLogOptions({ ...this.options, ...options });
+    }
+    getMinLevel() {
+        return this.options.minLevel ?? DEFAULT_OPTIONS.minLevel ?? LogLevel.INFO;
+    }
+    shouldLog(level, scopeMinLevel) {
+        const minLevel = scopeMinLevel ?? this.getMinLevel();
+        return LOG_LEVEL_RANK[level] >= LOG_LEVEL_RANK[minLevel];
+    }
+    createLogEntry(payload) {
+        const { level, message, topic, extra, data, module, traceId, traceParentId, labels } = payload;
+        return {
+            timestamp: Date.now(),
+            level,
+            message,
+            topic,
+            module,
+            traceId,
+            traceParentId,
+            labels,
+            extra,
+            data,
+        };
+    }
+    formatLevelTag(entry) {
+        const emoji = this.options.formatEmoji ? `${this.levelEmojis[entry.level]} ` : "";
+        if (entry.level === LogLevel.CRITICAL) {
+            return `[${emoji}*** ${entry.level} ***]`;
+        }
+        return `[${emoji}${entry.level}]`;
+    }
+    formatLog(entry) {
+        const parts = [];
+        if (this.options.formatTimestamp) {
+            parts.push(`[${new Date(entry.timestamp).toISOString()}]`);
+        }
+        parts.push(this.formatLevelTag(entry));
+        parts.push(`traceId=${entry.traceId} parent=${entry.traceParentId ?? "null"} labels=${formatScopeLabels(entry.labels)} module=${entry.module} topic=${entry.topic}`);
+        if (this.options.formatPrefix) {
+            parts.push(`prefix=${this.options.formatPrefix}`);
+        }
+        const message = entry.level === LogLevel.CRITICAL ? `>>> ${entry.message} <<<` : entry.message;
+        parts.push(`| ${message}`);
+        if (entry.extra) {
+            parts.push(`| extra=${entry.extra}`);
+        }
+        const dataText = formatDataValue(entry.data);
+        if (dataText) {
+            parts.push(`| data=${dataText}`);
+        }
+        return parts.join(" ");
+    }
+    emitLog(entry, formatted) {
+        switch (entry.level) {
+            case LogLevel.WARN:
+                console.warn(formatted);
+                break;
+            case LogLevel.ERROR:
+            case LogLevel.CRITICAL:
+                console.error(formatted);
+                break;
+            default:
+                console.log(formatted);
+        }
+    }
+    log(level, message, logScope, restParams, scopeMinLevel) {
+        if (!this.shouldLog(level, scopeMinLevel)) {
+            return;
+        }
+        validateLogScope(logScope);
+        if (!restParams.topic?.trim()) {
+            throw new Error("[LogManager] topic is required on every log call");
+        }
+        const { topic, extra } = restParams;
+        const data = resolveLogData(restParams);
+        const entry = this.createLogEntry({
+            level,
+            message,
+            topic,
+            extra,
+            data,
+            ...logScope,
+        });
+        const formatted = this.formatLog(entry);
+        this.emitLog(entry, formatted);
+        this.options.onLog?.(entry);
+        offerToLogPersist(entry);
+    }
+    generateTraceId() {
+        return generateUniqueId();
+    }
+    debug(message, logScope, restParams) {
+        this.log(LogLevel.DEBUG, message, logScope, restParams);
+    }
+    info(message, logScope, restParams) {
+        this.log(LogLevel.INFO, message, logScope, restParams);
+    }
+    success(message, logScope, restParams) {
+        this.log(LogLevel.SUCCESS, message, logScope, restParams);
+    }
+    warn(message, logScope, restParams) {
+        this.log(LogLevel.WARN, message, logScope, restParams);
+    }
+    error(message, logScope, restParams) {
+        this.log(LogLevel.ERROR, message, logScope, restParams);
+    }
+    critical(message, logScope, restParams) {
+        this.log(LogLevel.CRITICAL, message, logScope, restParams);
+    }
+    withScope(scope, options) {
+        const boundScope = { ...scope, labels: scope.labels ? { ...scope.labels } : undefined };
+        const scopeMinLevel = options?.minLevel;
+        const logger = {
+            debug: (message, restParams) => this.log(LogLevel.DEBUG, message, boundScope, restParams, scopeMinLevel),
+            info: (message, restParams) => this.log(LogLevel.INFO, message, boundScope, restParams, scopeMinLevel),
+            success: (message, restParams) => this.log(LogLevel.SUCCESS, message, boundScope, restParams, scopeMinLevel),
+            warn: (message, restParams) => this.log(LogLevel.WARN, message, boundScope, restParams, scopeMinLevel),
+            error: (message, restParams) => this.log(LogLevel.ERROR, message, boundScope, restParams, scopeMinLevel),
+            critical: (message, restParams) => this.log(LogLevel.CRITICAL, message, boundScope, restParams, scopeMinLevel),
+            resetScope: (patch) => {
+                const next = patchScope({
+                    scope: boundScope,
+                    patch,
+                    allowTraceMutation: false,
+                });
+                boundScope.module = next.module;
+                boundScope.traceId = next.traceId;
+                boundScope.traceParentId = next.traceParentId;
+                boundScope.labels = next.labels;
+            },
+        };
+        return { logger, scope: boundScope };
+    }
+}
+const logManager = LogManager.getInstance();
+
+function isScopeInput(input) {
+    return "scope" in input;
+}
+/**
+ * Returns a scoped logger — one entry for all call sites.
+ *
+ * - `{ module, traceId?, labels?, … }` — creates a scope (API handlers, one-shot calls)
+ * - `{ scope, minLevel? }` — binds an existing scope (`createScope`, `patchScope`, …)
+ */
+function createLogger(input) {
+    const { minLevel } = input;
+    const scopeOptions = minLevel != null ? { minLevel } : undefined;
+    if (isScopeInput(input)) {
+        return logManager.withScope(input.scope, scopeOptions).logger;
+    }
+    const scope = createScope({
+        module: input.module,
+        traceId: input.traceId?.trim() || logManager.generateTraceId(),
+        traceParentId: input.traceParentId,
+        labels: input.labels,
+    });
+    return logManager.withScope(scope, scopeOptions).logger;
+}
+
+export { updateTargetDetails as A, BaseValidator as B, CREATE_TARGET_ALREADY_EXISTS_MESSAGE as C, validateWith as D, validateWithSchema as E, registerLogPersistOffer as F, createScope as G, patchScope as H, withModule as I, LogLevel as L, MAX_POLL_TARGET_LIST_SIZE as M, OPTIMISTIC_LOCK_ERROR_CODE as O, PostListValidator as P, StatusCode as S, CategoryList as a, MAX_TARGET_LIST_PAGE_SIZE as b, OPTIMISTIC_LOCK_FAILED_MESSAGE as c, createLogger as d, createTarget as e, deleteTarget as f, generateResponse as g, getPossibleTarget as h, getTarget as i, getTargetList as j, getTargetTotalCount as k, handleSupabaseError as l, isCreateTargetAlreadyExistsError as m, isDevEnvironment as n, isOptimisticLockError as o, isOptimisticLockResponse as p, logDev as q, logDevGroup as r, logManager as s, patchTarget as t, pollTargetList as u, postListCreate as v, postLogListCreate as w, postTarget as x, scanTargetList as y, supabase as z };
+//# sourceMappingURL=create-logger-DyH3mZ8p.js.map