target-supabase-sdk 0.1.0

package/src/question-list/question-list.api.ts

@@ -0,0 +1,42 @@
+import { createTarget } from "../core.api";
+import { BaseValidator } from "../core.utils";
+import { QuestionList, CategoryQuestionList, QuestionListDetails } from "./question-list.interface";
+
+export class PostCreateQuestionListValidator extends BaseValidator<PostCreateQuestionListPayload> {
+  protected requiredFields: (keyof PostCreateQuestionListPayload)[] = ["name", "list"];
+  protected optionalFields: (keyof PostCreateQuestionListPayload)[] = [];
+
+  constructor() {
+    super();
+    // Add custom
+    this.addValidator((val) => {
+      return true;
+    });
+  }
+}
+
+export interface PostCreateQuestionListPayload {
+  name: QuestionListDetails["name"];
+  list: QuestionListDetails["list"];
+}
+
+export const postCreateQuestionList = async (payload: PostCreateQuestionListPayload) => {
+  return createTarget<QuestionList, PostCreateQuestionListPayload>({
+    payload: payload,
+    validator: PostCreateQuestionListValidator,
+    createFn: (validPayload) => {
+      const { name, list } = validPayload;
+      const details: QuestionListDetails = {
+        name,
+        list,
+      };
+      return {
+        name: validPayload.name,
+        category: CategoryQuestionList.QUESTION_LIST,
+        value: "",
+        tagList: [],
+        details,
+      };
+    },
+  });
+};

package/src/question-list/question-list.interface.ts

@@ -0,0 +1,21 @@
+import { Target } from "../core.interface";
+
+export interface Question {
+  ans: string;
+  reminder: string;
+}
+
+export type QuestionListDetails = {
+  /** Human readable name, should be same to Target.name */
+  name: string;
+  list: Question[];
+};
+
+export enum CategoryQuestionList {
+  QUESTION_LIST = "question-list",
+}
+
+export interface QuestionList extends Target {
+  category: CategoryQuestionList;
+  details: QuestionListDetails;
+}

package/src/review/review.api.ts

@@ -0,0 +1,145 @@
+import { cloneDeep } from "lodash-es";
+import { createTarget, getPossibleTarget, updateTargetDetails } from "../core.api";
+import { createResponse } from "../core.interface";
+import { BaseValidator } from "../core.utils";
+import { CategoryReview, Review, ReviewDetails } from "./review.interface";
+
+class PatchUpsertReviewValidator extends BaseValidator<ReviewDetails> {
+  protected requiredFields: (keyof ReviewDetails)[] = ["reviewTargetId", "reviewDomain", "reviewResult"];
+  protected optionalFields: (keyof ReviewDetails)[] = [];
+  protected ignoredFields: (keyof ReviewDetails)[] = ["reviewCount", "lastUpdated"];
+
+  constructor() {
+    super();
+    // Add custom
+    this.addValidator((val) => {
+      if (val.reviewResult == null || Object.values(val.reviewResult).some((v) => typeof v !== "number")) {
+        return "[Check reviewResult] reviewResult invalid";
+      }
+      return true;
+    });
+  }
+}
+
+export const patchUpsertReview = async (payload: ReviewDetails) => {
+  const validPayload = new PatchUpsertReviewValidator().validate(payload);
+  const { reviewTargetId, reviewDomain } = validPayload;
+
+  // Check redundancy
+  const { data: possibleReview } = await getPossibleTarget({
+    filterList: [
+      {
+        field: "category",
+        operator: "eq",
+        value: CategoryReview.REVIEW,
+      },
+      {
+        field: "details->>reviewTargetId",
+        operator: "eq",
+        value: reviewTargetId,
+      },
+      {
+        field: "details->>reviewDomain",
+        operator: "eq",
+        value: reviewDomain,
+      },
+    ],
+  });
+
+  if (possibleReview != null) {
+    const existingReview = possibleReview as Review;
+    const id = existingReview.id;
+    // Update
+    const data = await updateTargetDetails<Review, ReviewDetails>({
+      id,
+      updateFn: (details) => {
+        const incrementResult = validPayload.reviewResult;
+        if (incrementResult != null) {
+          const updatedResult = details.reviewResult != null ? cloneDeep(details.reviewResult) : {};
+          Object.entries(incrementResult).forEach(([key, value]) => {
+            updatedResult[key] = (updatedResult[key] ?? 0) + value;
+          });
+          return {
+            ...details,
+            reviewResult: updatedResult,
+            reviewCount: (details.reviewCount ?? 0) + 1,
+            lastUpdated: Date.now(),
+          };
+        }
+        return details;
+      },
+    });
+    return createResponse.success<Review>(data);
+  }
+  // Create
+  const { data: newReview } = await postReview({
+    reviewTargetId,
+    reviewDomain,
+  });
+  if (newReview == null) {
+    const msg = "[patchUpsertReview] Unable to create Review";
+    console.error(msg);
+    throw new Error(msg);
+  }
+  return createResponse.success<Review>(newReview);
+};
+
+export interface PostReviewPayload {
+  reviewTargetId: ReviewDetails["reviewTargetId"];
+  reviewDomain: ReviewDetails["reviewDomain"];
+}
+
+export class PostReviewValidator extends BaseValidator<PostReviewPayload> {
+  protected requiredFields: (keyof PostReviewPayload)[] = ["reviewTargetId", "reviewDomain"];
+  protected optionalFields: (keyof PostReviewPayload)[] = [];
+
+  constructor() {
+    super();
+    // Add custom
+    this.addValidator((val) => {
+      return true;
+    });
+  }
+}
+
+export const postReview = async (payload: PostReviewPayload) => {
+  return createTarget<Review, PostReviewPayload>({
+    payload: payload,
+    validator: PostReviewValidator,
+    checkRedundancyFilterList: [
+      {
+        field: "category",
+        operator: "eq",
+        value: CategoryReview.REVIEW,
+      },
+      {
+        field: "details->>reviewTargetId",
+        operator: "eq",
+        value: payload.reviewTargetId,
+      },
+      {
+        field: "details->>reviewDomain",
+        operator: "eq",
+        value: payload.reviewDomain,
+      },
+    ],
+    createFn: (validPayload) => {
+      const { reviewTargetId, reviewDomain } = validPayload;
+      const details: ReviewDetails = {
+        reviewTargetId,
+        reviewDomain,
+        lastUpdated: Date.now(),
+        reviewCount: 0,
+        reviewResult: {},
+      };
+      const reviewStr = `Review ${reviewTargetId} ${reviewDomain}`;
+      return {
+        name: reviewStr,
+        category: CategoryReview.REVIEW,
+        value: "",
+        tagList: [],
+        details,
+      };
+    },
+  });
+};

package/src/review/review.interface.ts

@@ -0,0 +1,26 @@
+import { Target } from "../core.interface";
+
+export enum ReviewDomain {
+  /** the larger the number, the more popular it is */
+  LIKES = "likes",
+}
+
+export type ReviewDetails = {
+  reviewTargetId: string;
+  lastUpdated: number;
+  reviewDomain: ReviewDomain;
+  /** Auto increment */
+  reviewCount?: number;
+  reviewResult?: {
+    /** reviewDomain */
+    [name: string]: number;
+  };
+};
+
+export enum CategoryReview {
+  REVIEW = "review",
+}
+export interface Review extends Target {
+  category: CategoryReview;
+  details: ReviewDetails;
+}

package/src/review-v2/apis/post-review-setting.api.ts

@@ -0,0 +1,35 @@
+import { createTarget, validateWith } from "../../core.api";
+import { BaseValidator } from "../../core.utils";
+import { ReviewSettingDetails, ReviewSetting, CategoryReviewSetting } from "../review-setting.interface";
+
+export interface PostReviewSettingPayload {
+  name: ReviewSettingDetails["name"];
+  questionList: ReviewSettingDetails["questionList"];
+}
+
+export class PostReviewSettingValidator extends BaseValidator<PostReviewSettingPayload> {
+  protected requiredFields: (keyof PostReviewSettingPayload)[] = ["name", "questionList"];
+  protected optionalFields: (keyof PostReviewSettingPayload)[] = [];
+}
+
+export const postReviewSetting = validateWith<PostReviewSettingPayload, PostReviewSettingValidator>(
+  PostReviewSettingValidator
+)(async (validPayload) => {
+  return createTarget<ReviewSetting, PostReviewSettingPayload>({
+    payload: validPayload,
+    createFn: (validPayload) => {
+      const { name, questionList } = validPayload;
+      const details: ReviewSettingDetails = {
+        name,
+        questionList,
+      };
+      return {
+        name,
+        category: CategoryReviewSetting.REVIEW_SETTING,
+        value: "",
+        tagList: [],
+        details,
+      };
+    },
+  });
+});

package/src/review-v2/apis/post-review.api.ts

@@ -0,0 +1,59 @@
+import { createTarget, getTarget, validateWith } from "../../core.api";
+import { BaseValidator } from "../../core.utils";
+import { CategoryReview, ReviewV2 as Review, ReviewV2Details as ReviewDetails } from "../review.interface";
+import { ReviewSetting } from "../review-setting.interface";
+
+export interface PostReviewPayload {
+  targetId: ReviewDetails["targetId"];
+  settingId: ReviewDetails["settingId"];
+  resultList: ReviewDetails["resultList"];
+}
+
+export class PostReviewValidator extends BaseValidator<PostReviewPayload> {
+  protected requiredFields: (keyof PostReviewPayload)[] = ["targetId", "targetId", "resultList"];
+  protected optionalFields: (keyof PostReviewPayload)[] = [];
+}
+
+export const postReview = validateWith<PostReviewPayload, PostReviewValidator>(PostReviewValidator)(
+  async (validPayload: PostReviewPayload) => {
+    const { targetId, settingId, resultList } = validPayload;
+
+    // Check Target
+    if (targetId != null) {
+      const { data: possibleTarget } = await getTarget({
+        id: targetId,
+      });
+      // TODO
+    }
+
+    // Check ReviewSetting
+    const { data: _reviewSetting } = await getTarget({
+      id: settingId,
+    });
+    if (_reviewSetting == null) {
+      console.error("[postReview] ReviewSetting not found");
+      throw new Error("[postReview] ReviewSetting not found");
+    }
+    const reviewSetting = _reviewSetting as ReviewSetting;
+
+    return createTarget<Review, PostReviewPayload>({
+      payload: validPayload,
+      createFn: (validPayload) => {
+        const { targetId, settingId, resultList } = validPayload;
+        const details: ReviewDetails = {
+          targetId,
+          settingId,
+          resultList,
+        };
+        const name = `Review on ${reviewSetting?.details?.name}`;
+        return {
+          name,
+          category: CategoryReview.REVIEW,
+          value: "",
+          tagList: [],
+          details,
+        };
+      },
+    });
+  }
+);

package/src/review-v2/review-setting.interface.ts

@@ -0,0 +1,26 @@
+import { Target } from "../core.interface";
+
+export interface ReviewSetting extends Target {
+  category: CategoryReviewSetting;
+  details: ReviewSettingDetails;
+}
+
+export enum CategoryReviewSetting {
+  REVIEW_SETTING = "review-setting",
+}
+
+export type ReviewSettingDetails = {
+  name: string;
+  questionList: ReviewQuestion[];
+};
+
+export interface ReviewQuestion {
+  title: string;
+  /** uuid */
+  key: string;
+  type: "$boolean" | "$text" | "$number" | "$choice" | "$custom";
+  /** To provide data when rendering a question */
+  refTargetId?: string;
+  /** To render a custom question */
+  customTargetId?: string;
+}

package/src/review-v2/review.interface.ts

@@ -0,0 +1,23 @@
+import { Target } from "../core.interface";
+import { ReviewQuestion } from "./review-setting.interface";
+
+/** Instance of ReviewSetting */
+export interface ReviewV2 extends Target {
+  category: CategoryReview;
+  details: ReviewV2Details;
+}
+
+export enum CategoryReview {
+  REVIEW = "review",
+}
+
+export type ReviewV2Details = {
+  targetId: string | null;
+  /** How to collect reviews from users and how to parse the results */
+  settingId: string;
+  resultList: ReviewResult[];
+};
+
+export interface ReviewResult extends ReviewQuestion {
+  answer: unknown;
+}

package/src/service/api.interface.ts

@@ -0,0 +1,47 @@
+import { Target } from "../core.interface";
+import { Field, Lifecycle } from "./base.interface";
+
+export interface Api extends Target {
+  /** "core.post.target.0" 唯一键 领域 + METHOD + content + VERSION */
+  value: string;
+  category: CategoryApi;
+  details: ApiDetails;
+}
+
+export enum CategoryApi {
+  API = "api",
+}
+
+export enum ApiMethod {
+  POST = "POST",
+  GET = "GET",
+  PUT = "PUT",
+  DELETE = "DELETE",
+}
+
+export interface ApiDetails {
+  method: ApiMethod;
+  /** /v0/core/target */
+  path: string;
+  request: {
+    query: {
+      [key: string]: Field;
+    };
+  };
+  response: {
+    "200": { [key: string]: Field };
+  };
+  manifestVersion: number;
+  lifecycle: Lifecycle;
+  /** TODO "application/octet-stream" */
+  // contentType: string;
+  /** TODO "application/json" */
+  // responseType: string;
+  /** TODO 安全模型/ 风控 / 限制 / 可观测性 & 审计 */
+  // auth: unknown;
+  // rate_limit: {
+  //   key: "user_id";
+  //   limit: 60;
+  //   window: "1m";
+  // };
+}

package/src/service/base.interface.ts

@@ -0,0 +1,97 @@
+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 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 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<{
+    key: string;
+    value: string;
+  }>;
+  manifestVersion: number;
+}
+

package/src/service/service.interface.ts

@@ -0,0 +1,27 @@
+import { Target } from "../core.interface";
+import { Lifecycle } from "./base.interface";
+
+export interface Service extends Target {
+  /** "storage-service" 唯一键 */
+  value: string;
+  category: CategoryService;
+  details: ServiceDetails;
+}
+
+export enum CategoryService {
+  SERVICE = "service",
+}
+
+export enum ServiceStatus {
+  ACTIVE = "ACTIVE",
+  DEPRECATED = "DEPRECATED",
+  SUNSET = "SUNSET",
+}
+
+export interface ServiceDetails {
+  /** 能力 Api keys */
+  apis: string[];
+  /** 依赖的服务 Service keys */
+  dependencies: string[];
+  lifecycle: Lifecycle;
+}

package/src/supabase.ts

@@ -0,0 +1,143 @@
+import { createClient, SupabaseClient } from "@supabase/supabase-js";
+import { logDev, logDevGroup } from "./core.utils";
+
+interface SupabaseConfig {
+  main: {
+    url: string;
+    anonKey: string;
+  };
+  auth: {
+    url: string;
+    anonKey: string;
+  } | null;
+}
+
+export interface SupabaseInitializerParams {
+  supabaseUrl: string;
+  supabaseAnonKey: string;
+  supabaseNeedAuthUrl?: string;
+  supabaseNeedAuthAnonKey?: string;
+}
+
+export class SupabaseInitializer {
+  private static instance: SupabaseInitializer;
+  private isInitialized = false;
+  private _mainClient: SupabaseClient | null = null;
+  private _authClient: SupabaseClient | null = null;
+
+  private constructor() {}
+
+  static getInstance(): SupabaseInitializer {
+    if (!SupabaseInitializer.instance) {
+      SupabaseInitializer.instance = new SupabaseInitializer();
+    }
+    return SupabaseInitializer.instance;
+  }
+
+  /**
+   * Initialize Supabase clients
+   */
+  async initialize(
+    params: SupabaseInitializerParams
+  ): Promise<{ supabase: SupabaseClient; supabaseAuth: SupabaseClient | null }> {
+    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 };
+  }
+
+  private validateEnvironmentVariables({
+    supabaseUrl,
+    supabaseAnonKey,
+    supabaseNeedAuthUrl,
+    supabaseNeedAuthAnonKey,
+  }: SupabaseInitializerParams): SupabaseConfig {
+    const mainUrl = supabaseUrl;
+    const mainAnonKey = supabaseAnonKey;
+    const authUrl = supabaseNeedAuthUrl;
+    const authAnonKey = supabaseNeedAuthAnonKey;
+
+    if (!mainUrl || !mainAnonKey) {
+      throw new Error("Missing required Supabase environment variables: VITE_SUPABASE_URL, VITE_SUPABASE_ANON_KEY");
+    }
+
+    return {
+      main: { url: mainUrl, anonKey: mainAnonKey },
+      auth: authUrl && authAnonKey ? { url: authUrl, anonKey: authAnonKey } : null,
+    };
+  }
+
+  private logConfiguration(config: SupabaseConfig) {
+    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(): SupabaseClient {
+    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(): SupabaseClient | null {
+    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;
+  }
+}