target-supabase-sdk 0.1.9 → 0.2.1

package/src/repo/repo.script-loader.ts

@@ -1,16 +1,12 @@
 import { createHash } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-import { LoggerWithContext } from "../shared/log/log-manager";
+import type { LoggerWithScope } from "../shared/log";
 import { resolvePathFromCwd, toFileImportHref } from "../shared/utils/config-path.utils";
-import { TaskRepoScriptRecord } from "../task/task-repo-context";
-import {
-    getScriptLoadKey,
-    LoadedRepoContext,
-    normalizeRepoContextModule,
-} from "./repo-context.utils";
+import type { TaskRepoScriptRecord } from "../task/task-repo-context";
+import { getScriptLoadKey, type LoadedRepoContext, normalizeRepoContextModule } from "./repo-context.utils";
 
 const importedModuleCache = new Map<string, LoadedRepoContext>();
 
@@ -41,7 +37,7 @@ export async function loadRepoContextFromScript({
     script,
     taskTypeKey,
 }: {
-    logger: LoggerWithContext;
+    logger: LoggerWithScope;
     script: TaskRepoScriptRecord;
     taskTypeKey: string;
 }): Promise<LoadedRepoContext | null> {
@@ -49,7 +45,7 @@ export async function loadRepoContextFromScript({
     const cacheKey = `${taskTypeKey}@${loadKey}`;
     const cached = importedModuleCache.get(cacheKey);
     if (cached != null) {
-        logger.info("命中 Repo 脚本模块缓存", { topic: "repo", context: { cacheKey } });
+        logger.info("命中 Repo 脚本模块缓存", { topic: "repo", data: { cacheKey } });
         return cached;
     }
 
@@ -58,16 +54,16 @@ export async function loadRepoContextFromScript({
     try {
         let moduleExports: unknown;
         if (source != null && source.trim() !== "") {
-            logger.info("从 source 动态加载 Repo 脚本", { topic: "repo", context: { scriptId: script.id } });
+            logger.info("从 source 动态加载 Repo 脚本", { topic: "repo", data: { scriptId: script.id } });
             moduleExports = await importFromSource(source, cacheKey);
         } else if (modulePath != null && modulePath.trim() !== "") {
             logger.info("从 modulePath 动态加载 Repo 脚本", {
                 topic: "repo",
-                context: { scriptId: script.id, modulePath },
+                data: { scriptId: script.id, modulePath },
             });
             moduleExports = await importFromFilePath(modulePath);
         } else {
-            logger.warn("脚本缺少 source 或 modulePath", { topic: "repo", context: { scriptId: script.id } });
+            logger.warn("脚本缺少 source 或 modulePath", { topic: "repo", data: { scriptId: script.id } });
             return null;
         }
 
@@ -75,7 +71,7 @@ export async function loadRepoContextFromScript({
         if (context == null) {
             logger.warn("脚本模块未导出合法的 TaskRepoContext", {
                 topic: "repo",
-                context: { scriptId: script.id, exportName: exportName ?? "default" },
+                data: { scriptId: script.id, exportName: exportName ?? "default" },
             });
             return null;
         }
@@ -86,7 +82,7 @@ export async function loadRepoContextFromScript({
     } catch (error) {
         logger.error("动态加载 Repo 脚本失败", {
             topic: "repo",
-            context: { scriptId: script.id, error: error instanceof Error ? error.message : error },
+            data: { scriptId: script.id, error: error instanceof Error ? error.message : error },
         });
         return null;
     }
@@ -98,7 +94,7 @@ export async function loadRepoContextFromUrl({
     taskTypeKey,
     exportName,
 }: {
-    logger: LoggerWithContext;
+    logger: LoggerWithScope;
     url: string;
     taskTypeKey: string;
     exportName?: string;
@@ -107,18 +103,18 @@ export async function loadRepoContextFromUrl({
     const cacheKey = `${taskTypeKey}@url:${href}`;
     const cached = importedModuleCache.get(cacheKey);
     if (cached != null) {
-        logger.info("命中 Repo URL 模块缓存", { topic: "repo", context: { cacheKey } });
+        logger.info("命中 Repo URL 模块缓存", { topic: "repo", data: { cacheKey } });
         return cached;
     }
 
     try {
-        logger.info("从 Repo URL 动态加载脚本", { topic: "repo", context: { url, href } });
+        logger.info("从 Repo URL 动态加载脚本", { topic: "repo", data: { url, href } });
         const moduleExports = await import(href);
         const context = normalizeRepoContextModule(moduleExports, taskTypeKey, exportName);
         if (context == null) {
             logger.warn("Repo URL 模块未导出合法的 TaskRepoContext", {
                 topic: "repo",
-                context: { url, exportName: exportName ?? "default" },
+                data: { url, exportName: exportName ?? "default" },
             });
             return null;
         }
@@ -128,7 +124,7 @@ export async function loadRepoContextFromUrl({
     } catch (error) {
         logger.error("从 Repo URL 动态加载失败", {
             topic: "repo",
-            context: { url, error: error instanceof Error ? error.message : error },
+            data: { url, error: error instanceof Error ? error.message : error },
         });
         return null;
     }

package/src/service/base.interface.ts

@@ -1,97 +1,88 @@
-import { Target } from "../core.interface";
-
-export enum LifecycleStatus {
-  ACTIVE = "ACTIVE",
-  DEPRECATED = "DEPRECATED",
-  SUNSET = "SUNSET",
-}
-
-export interface Lifecycle {
-  status: LifecycleStatus;
-  /** YYYY-MM-DD */
-  activeSince: string;
-  deprecatedAt: string | null;
-  sunsetAt: string | null;
+export enum ServiceLifecycleStatus {
+    ACTIVE = "ACTIVE",
+    DEPRECATED = "DEPRECATED",
+    SUNSET = "SUNSET",
 }
 
-export type Field =
-  | {
-    type: "string";
-    nullable: boolean;
-    required: boolean;
-    /** 1 */
-    minLength: number;
-    /** 64 */
-    maxLength: number;
-    /** ^[a-z0-9_-]+$ */
-    pattern: string;
-  }
-  | {
-    type: "number";
-    nullable: boolean;
-    required: boolean;
-    /** 1 */
-    minimum: number;
-    /** 64 */
-    maximum: number;
-  }
-  | {
-    type: "boolean";
-    nullable: boolean;
-    required: boolean;
-  }
-  | {
-    type: "enum";
-    nullable: boolean;
-    required: boolean;
-    /** 'core.Gender.0' */
-    enumKey: string;
-  }
-  | {
-    type: "array";
-    nullable: boolean;
-    required: boolean;
-    /** 'string'|'number'|'boolean'|'enum.enumKey'|'ref.refKey' */
-    itemType: string;
-  }
-  | {
-    /** Object */
-    type: "ref";
-    nullable: boolean;
-    required: boolean;
-    /** 'core.QuestionReview.0' */
-    refKey: string;
-  };
-
-
-export interface TargetDescriptor extends Target {
-  /** "core.QuestionReview.0" 唯一键 领域 + targetName + VERSION */
-  value: string;
-  category: 'target-descriptor';
-  details: TargetDescriptorDetails;
+export interface ServiceLifecycle {
+    status: ServiceLifecycleStatus;
+    /** YYYY-MM-DD */
+    activeSince: string;
+    deprecatedAt: string | null;
+    sunsetAt: string | null;
 }
 
-export interface TargetDescriptorDetails {
-  list: Array<{
-    name: string;
-  } & Field>;
-  refMap?: Record<string, TargetDescriptor>;
-  enumMap?: Record<string, string[]>;
-  manifestVersion: number;
-}
-
-export interface EnumDescriptor extends Target {
-  /** "core.Gender.0" 唯一键 领域 + enumName + VERSION */
-  value: string;
-  category: 'target-descriptor';
-  details: EnumDescriptorDetails;
-}
-
-export interface EnumDescriptorDetails {
-  list: Array<{
+/** Inline enum members (no registry lookup). */
+export type EnumMembers = ReadonlyArray<{
     key: string;
     value: string;
-  }>;
-  manifestVersion: number;
-}
+}>;
+
+/**
+ * Schema node without a field name — used for array items and anonymous nesting.
+ * Named properties use {@link FieldDefinition} (`fieldName` + `SchemaDefinition`).
+ */
+export type SchemaDefinition =
+    | {
+          type: "string";
+          nullable: boolean;
+          optional: boolean;
+          /** string length */
+          min?: number;
+          /** string length */
+          max?: number;
+          /** e.g. ^[a-z0-9_-]+$ */
+          regex?: string;
+          default?: string;
+      }
+    | {
+          type: "number";
+          nullable: boolean;
+          optional: boolean;
+          min?: number;
+          max?: number;
+          default?: number;
+      }
+    | {
+          type: "boolean";
+          nullable: boolean;
+          optional: boolean;
+          default?: boolean;
+      }
+    | {
+          type: "unknown";
+          nullable: boolean;
+          optional: boolean;
+          default?: unknown;
+      }
+    | {
+          type: "enum";
+          nullable: boolean;
+          optional: boolean;
+          members: EnumMembers;
+          /** Must match a `members[].key` */
+          defaultKey?: string;
+      }
+    | {
+          type: "object";
+          nullable: boolean;
+          optional: boolean;
+          fields: FieldDefinition[];
+          default?: Record<string, unknown>;
+      }
+    | {
+          type: "array";
+          nullable: boolean;
+          optional: boolean;
+          items: SchemaDefinition;
+          /** min/max item count */
+          min?: number;
+          max?: number;
+          default?: unknown;
+      };
 
+/**
+ * Named field schema. `fieldName` is required for introspection (walk paths, docs, forms).
+ * Use `fields: FieldDefinition[]` — not `Record<string, …>` — so the name has a single source of truth.
+ */
+export type FieldDefinition = { fieldName: string } & SchemaDefinition;

package/src/service/index.ts

@@ -0,0 +1,173 @@
+import { scanTargetList } from "../core.api";
+import { generateResponse, type SupabaseResponse } from "../core.interface";
+import { createLogger } from "../shared/log";
+import { ServiceLifecycleStatus } from "./base.interface";
+import { getService } from "./service.api";
+import { CategoryService, type Service } from "./service.interface";
+
+export type {
+    EnumMembers,
+    FieldDefinition,
+    SchemaDefinition,
+    ServiceLifecycle,
+} from "./base.interface";
+export { ServiceLifecycleStatus } from "./base.interface";
+export type { GetApiPayload, GetServicePayload, PostApiPayload, PostServicePayload } from "./service.api";
+export {
+    apiDetailsSchema,
+    fieldDefinitionSchema,
+    getApi,
+    getApiSchema,
+    getService,
+    getServiceSchema,
+    postApi,
+    postApiSchema,
+    postService,
+    postServiceSchema,
+    schemaDefinitionSchema,
+    serviceDetailsSchema,
+    serviceLifecycleSchema,
+} from "./service.api";
+export type { Api, ApiDetails, Service, ServiceDetails } from "./service.interface";
+export { ApiMethod, CategoryApi, CategoryService } from "./service.interface";
+
+export interface DiscoverServiceInput {
+    /** {@link Service.value} */
+    value: string;
+    traceId?: string;
+}
+
+const DISCOVER_LIFECYCLE_STATUS = ServiceLifecycleStatus.ACTIVE;
+const SERVICE_LIFECYCLE_STATUS_FIELD = "details->lifecycle->>status" as const;
+
+async function lookupServicePrimary(value: string): Promise<Service | null> {
+    const response = await getService({ value, lifecycleStatus: DISCOVER_LIFECYCLE_STATUS });
+    return response.data ?? null;
+}
+
+async function lookupServiceByScan(value: string): Promise<Service | null> {
+    const { data } = await scanTargetList<Service>({
+        category: CategoryService.SERVICE,
+        orderBy: { field: "value", ascending: true },
+        maxRows: 1,
+        filterList: [
+            { field: "value", operator: "eq", value },
+            {
+                field: SERVICE_LIFECYCLE_STATUS_FIELD,
+                operator: "eq",
+                value: DISCOVER_LIFECYCLE_STATUS,
+            },
+        ],
+    });
+
+    return data?.[0] ?? null;
+}
+
+async function resolveDiscoverFailureReason(value: string): Promise<"not-found" | "not-available"> {
+    const response = await getService({ value });
+    if (response.data == null) {
+        return "not-found";
+    }
+    return "not-available";
+}
+
+/**
+ * Discover a single service by {@link Service.value}.
+ * Only returns services with `lifecycle.status === ACTIVE` (filtered at query time).
+ *
+ * Lookup: primary `getService` → fallback `scanTargetList` by value.
+ */
+export async function discoverService(input: DiscoverServiceInput): Promise<SupabaseResponse<Service>> {
+    const value = input.value.trim();
+    const logger = createLogger({
+        module: "discoverService",
+        traceId: input.traceId,
+        labels: { serviceValue: value },
+    });
+
+    if (value === "") {
+        const message = "discoverService: value must not be empty";
+        logger.warn(message, { topic: "service", data: { value: input.value } });
+        return generateResponse.error(message, undefined, "SERVICE_VALUE_REQUIRED") as SupabaseResponse<Service>;
+    }
+
+    try {
+        logger.info("开始发现服务", {
+            topic: "service",
+            data: { value, lifecycleStatus: DISCOVER_LIFECYCLE_STATUS },
+        });
+
+        let service = await lookupServicePrimary(value);
+        let source: "primary" | "scan" = "primary";
+
+        if (service == null) {
+            logger.warn("主路径未命中，尝试 catalog 扫描回退", {
+                topic: "service",
+                data: { value, step: "scan-fallback", lifecycleStatus: DISCOVER_LIFECYCLE_STATUS },
+            });
+            service = await lookupServiceByScan(value);
+            source = "scan";
+        }
+
+        if (service == null) {
+            const reason = await resolveDiscoverFailureReason(value);
+            if (reason === "not-available") {
+                const message = `Service ${value} is not available (lifecycle is not ACTIVE)`;
+                logger.warn("服务已注册但不可用", {
+                    topic: "service",
+                    data: { value, step: "not-available", lifecycleStatus: DISCOVER_LIFECYCLE_STATUS },
+                });
+                return generateResponse.error(message, undefined, "SERVICE_NOT_AVAILABLE") as SupabaseResponse<Service>;
+            }
+
+            const message = `Service not found: ${value}`;
+            logger.error("服务未发现", {
+                topic: "service",
+                data: { value, step: "not-found", tried: ["primary", "scan"] },
+            });
+            return generateResponse.error(message, undefined, "SERVICE_NOT_FOUND") as SupabaseResponse<Service>;
+        }
+
+        logger.info("服务发现成功", {
+            topic: "service",
+            data: {
+                value,
+                source,
+                serviceId: service.id,
+                lifecycleStatus: service.details.lifecycle.status,
+                apiKeyCount: service.details.apiKeys.length,
+                dependencyCount: service.details.dependencies.length,
+            },
+        });
+
+        return generateResponse.success(service);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error("服务发现失败", {
+            topic: "service",
+            data: { value, message },
+        });
+
+        let service: Service | null = null;
+        try {
+            service = await lookupServiceByScan(value);
+        } catch (fallbackError) {
+            const fallbackMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+            logger.error("扫描回退失败", {
+                topic: "service",
+                data: { value, message: fallbackMessage },
+            });
+            return generateResponse.error(message, undefined, "SERVICE_DISCOVER_FAILED") as SupabaseResponse<Service>;
+        }
+
+        if (service != null) {
+            logger.warn("主路径异常后扫描回退成功", {
+                topic: "service",
+                data: { value, serviceId: service.id, primaryError: message },
+            });
+            return generateResponse.success(service);
+        }
+
+        return generateResponse.error(message, undefined, "SERVICE_DISCOVER_FAILED") as SupabaseResponse<Service>;
+    }
+}