sonamu 0.7.21 → 0.7.23

package/src/cache/index.ts

@@ -0,0 +1,16 @@
+// Cache manager factory
+export { createCacheManager, createTestCacheManager } from "./cache-manager";
+
+// Decorator
+export { cache, getCacheManagerRef, setCacheManagerRef } from "./decorator";
+
+// Drivers & Store builder
+export {
+  drivers,
+  fileDriver,
+  knexDriver,
+  memoryDriver,
+  redisBusDriver,
+  redisDriver,
+  store,
+} from "./drivers";

package/src/cache/types.ts

@@ -0,0 +1,32 @@
+import type { BentoCache } from "bentocache";
+import type { RawCommonOptions } from "bentocache/types";
+
+/**
+ * 캐시 설정 (sonamu.config.ts에서 사용)
+ */
+export type CacheConfig = ConstructorParameters<typeof BentoCache>[0];
+
+/**
+ * @cache 데코레이터 옵션
+ */
+export type CacheDecoratorOptions = {
+  /**
+   * 캐시 키
+   * - 문자열: 고정 키 (args가 자동으로 suffix로 추가됨)
+   * - 함수: 인자를 받아 키 생성
+   * - 미지정: ModelName.methodName:serializedArgs 형태로 자동 생성
+   */
+  key?: string | ((...args: unknown[]) => string);
+
+  /**
+   * 사용할 스토어 이름
+   * 미지정 시 default 스토어 사용
+   */
+  store?: string;
+} & RawCommonOptions;
+
+/**
+ * CacheManager 타입 (BentoCache 확장)
+ */
+// biome-ignore lint/suspicious/noExplicitAny: BentoCache의 제네릭 타입을 그대로 사용
+export type CacheManager = BentoCache<any>;

package/src/database/base-model.ts

@@ -1,10 +1,11 @@
 /** biome-ignore-all lint/suspicious/noExplicitAny: Puri의 타입은 개별 모델에서 확정되므로 BaseModel에서는 any를 허용함 */
-
+import { getLogger, type Logger } from "@logtape/logtape";
 import type { Knex } from "knex";
 import { cloneDeep, group, isObject, omit, set } from "radashi";
 import type { ListResult } from "..";
 import { Sonamu } from "../api";
 import { EntityManager } from "../entity/entity-manager";
+import { convertDomainToCategory } from "../logger/category";
 import type { DatabaseSchemaExtend, SonamuQueryMode } from "../types/types";
 import { getJoinTables, getTableNamesFromWhere } from "../utils/sql-parser";
 import { chunk } from "../utils/utils";
@@ -33,12 +34,15 @@ export class BaseModelClass<
   TSubsetQueries extends Record<TSubsetKey, PuriSubsetFn> = never,
   TLoaderQueries extends PuriLoaderQueries<TSubsetKey> = never,
 > {
-  public modelName: string = "Unknown";
+  protected readonly logger: Logger;
 
   constructor(
+    public readonly modelName: string = this.constructor.name,
     protected subsetQueries?: TSubsetQueries,
     protected loaderQueries?: TLoaderQueries,
-  ) {}
+  ) {
+    this.logger = getLogger(convertDomainToCategory(this.modelName, "model"));
+  }
 
   getDB(which: DBPreset): Knex {
     return DB.getDB(which);

package/src/database/code-generator.ts

@@ -3,7 +3,7 @@ import { diff } from "radashi";
 import type { MigrationColumn, MigrationIndex } from "../types/types";
 import { differenceWith, intersectionBy } from "../utils/utils";
 
-export class CodeGenerator {
+class CodeGeneratorClass {
   getAlterColumnsTo(entityColumns: MigrationColumn[], dbColumns: MigrationColumn[]) {
     const columnsTo = {
       add: [] as MigrationColumn[],
@@ -55,3 +55,5 @@ export class CodeGenerator {
     return indexesTo;
   }
 }
+
+export const CodeGenerator = new CodeGeneratorClass();

package/src/database/db.ts

@@ -1,9 +1,9 @@
 import { AsyncLocalStorage } from "async_hooks";
-import knex, { type Knex } from "knex";
+import type { Knex } from "knex";
 import { assign } from "radashi";
-
 import { Sonamu } from "../api";
 import type { DatabaseConfig, SonamuConfig } from "../api/config";
+import { createKnexInstance } from "./knex";
 import { TransactionContext } from "./transaction-context";
 
 /**
@@ -49,7 +49,7 @@ export class DBClass {
       } else if (this.wdb) {
         return this.wdb;
       } else {
-        this.wdb = knex({
+        this.wdb = createKnexInstance({
           ...dbConfig.test,
           // 단일 풀
           pool: {
@@ -65,7 +65,7 @@ export class DBClass {
 
     if (!this[instanceName]) {
       const config = this.getDBConfig(which);
-      this[instanceName] = knex(config);
+      this[instanceName] = createKnexInstance(config);
     }
 
     return this[instanceName];
@@ -112,7 +112,7 @@ export class DBClass {
   public generateDBConfig(config: SonamuConfig["database"]): SonamuDBConfig {
     const defaultKnexConfig: Partial<DatabaseConfig> = assign(
       {
-        client: "pg",
+        client: "postgresql",
         pool: {
           min: 1,
           max: 5,

package/src/database/knex.ts

@@ -0,0 +1,34 @@
+import type { Knex } from "knex";
+import knex from "knex";
+
+export function createKnexInstance(config: Knex.Config): Knex {
+  config.pool = {
+    ...(config.pool ?? {}),
+    propagateCreateError: false,
+    idleTimeoutMillis: 10000,
+    reapIntervalMillis: 1000,
+    acquireTimeoutMillis: 30000,
+    createTimeoutMillis: 30000,
+    afterCreate: ((conn: Knex.Client, done: (err: Error | null, conn: Knex.Client) => void) => {
+      conn.on("error", (err: Error) => {
+        Object.defineProperty(conn, "__knex__disposed", {
+          value: err,
+          writable: true,
+          configurable: true,
+          enumerable: true,
+        });
+      });
+
+      done(null, conn);
+    }) satisfies Knex.PoolConfig["afterCreate"],
+  };
+
+  const knexInstance = knex(config);
+  knexInstance.client.validateConnection = (connection: unknown) => {
+    return (
+      typeof connection === "object" && connection !== null && !("__knex__disposed" in connection)
+    );
+  };
+
+  return knexInstance;
+}

package/src/database/puri.types.ts

@@ -342,9 +342,8 @@ export type InsertData<T> = Omit<
 export type InsertResult = Pick<QueryResult<any>, "command" | "rowCount" | "rows" | "oid">;
 
 // SubsetQuery를 위한 타입 유틸리티
-export type ExtractTTables<T extends Puri<any, any, any>> = T extends Puri<any, infer TTables, any>
-  ? TTables
-  : never;
+export type ExtractTTables<T extends Puri<any, any, any>> =
+  T extends Puri<any, infer TTables, any> ? TTables : never;
 export type UnionExtractedTTables<
   SubsetKey extends string,
   SubsetQueries extends Record<SubsetKey, PuriSubsetFn>,

package/src/database/upsert-builder.ts

@@ -148,8 +148,11 @@ export class UpsertBuilder {
           rowValue.use ??= "id";
           table.references.add(`${rowValue.of}.${rowValue.use}`);
           return [rowKey, rowValue];
+        } else if (isArray(rowValue)) {
+          // 배열은 그대로 저장
+          return [rowKey, rowValue];
         } else if (typeof rowValue === "object" && !(rowValue instanceof Date)) {
-          // object인 경우 JSON으로 변환
+          // 일반 object인 경우 JSON으로 변환
           return [rowKey, rowValue === null ? null : JSON.stringify(rowValue)];
         } else {
           return [rowKey, rowValue];
@@ -292,11 +295,62 @@ export class UpsertBuilder {
           // INSERT 모드 - RETURNING 사용
           resultRows = await wdb.insert(dataForDb).into(tableName).returning(selectFields);
         } else {
-          // UPSERT 모드 - onConflict 사용 (unique index 없으면 PK fallback)
-          const conflictColumns = table.uniqueIndexes[0]?.columns.map((c) => c.name) ?? ["id"];
+          // UPSERT 모드 - id 없는 row들의 id를 사전 조회로 채우기
+          const rowsWithoutId = dataForDb.filter((row) => !row.id);
+
+          if (rowsWithoutId.length > 0 && table.uniqueIndexes.length > 0) {
+            // 모든 uniqueIndexes로 기존 레코드 조회
+            for (const uniqueIndex of table.uniqueIndexes) {
+              const columns = uniqueIndex.columns.map((c) => c.name);
+
+              // 조회할 조건들 추출 (각 row의 unique 컬럼 값들)
+              const conditions: unknown[][] = [];
+              for (const row of rowsWithoutId) {
+                const values = columns.map((col) => row[col]);
+                // null이 포함된 조건은 제외 (PostgreSQL UNIQUE는 NULL 무시)
+                if (!values.some((v) => v == null)) {
+                  conditions.push(values);
+                }
+              }
+
+              if (conditions.length === 0) continue;
+
+              // 배치 SELECT
+              const existingRows = (await wdb(tableName)
+                .whereIn(columns, conditions as Record<string, unknown>[][])
+                .select("id", ...columns)) as Record<string, unknown>[];
+
+              // Map 생성: unique 컬럼 조합 → id
+              const existingMap = new Map<string, number>();
+              for (const existing of existingRows) {
+                const key = columns
+                  .map((col) => String(existing[col] ?? ""))
+                  .join("---delimiter---");
+                const id = existing.id;
+                if (typeof id === "number") {
+                  existingMap.set(key, id);
+                }
+              }
+
+              // id 없는 row들에 매칭되는 id 채우기
+              for (const row of rowsWithoutId) {
+                if (row.id) continue; // 이미 다른 uniqueIndex에서 채워진 경우 스킵
+
+                const key = columns.map((col) => String(row[col] ?? "")).join("---delimiter---");
+                const existingId = existingMap.get(key);
+
+                if (existingId) {
+                  row.id = existingId;
+                }
+              }
+            }
+          }
+
+          // onConflict는 id만 사용 (모든 uniqueIndexes는 이미 사전 조회로 처리됨)
+          const conflictColumns = ["id"];
 
           const allColumns = Object.keys(dataForDb[0]);
-          let updateColumns = allColumns.filter((c) => !conflictColumns.includes(c));
+          let updateColumns = allColumns.filter((c) => c !== "id");
 
           // inherit 옵션 처리 - inherit 컬럼은 update 대상에서 제외
           if (options?.inherit?.length) {

package/src/index.ts

@@ -3,8 +3,11 @@ export * from "./api/config";
 export type * from "./api/context";
 export * from "./api/decorators";
 export * from "./api/sonamu";
+export { cache } from "./cache/decorator";
+export type { CacheDecoratorOptions } from "./cache/types";
 export * from "./database/base-model";
 export * from "./database/base-model.types";
+export * from "./database/code-generator";
 export * from "./database/db";
 export * from "./database/puri";
 export * from "./database/puri.types";
@@ -15,6 +18,7 @@ export * from "./entity/entity";
 export * from "./entity/entity-manager";
 export * from "./exceptions/error-handler";
 export * from "./exceptions/so-exceptions";
+export * from "./migration/code-generation";
 export * from "./migration/migration-set";
 export * from "./migration/migrator";
 export * from "./migration/postgresql-schema-reader";

package/src/logger/category.ts

@@ -0,0 +1,42 @@
+// NOTE: import * as inflection 혹은 import { underscore } 사용 시 오류 발생.
+import inflection from "inflection";
+import { asArray } from "../utils/model";
+
+// 두 카테고리가 동일한지 확인
+export function isSameCategory(
+  categoryA: readonly string[],
+  categoryB: string | string[],
+): boolean {
+  const categoryBArr = asArray(categoryB);
+  if (categoryA.length !== categoryBArr.length) {
+    return false;
+  }
+
+  return categoryA.every((category, index) => categoryBArr[index] === category);
+}
+
+// 로깅 카테고리를 지정합니다.
+// 예: SomeAgentClass -> ["sonamu", "agent", "some-agent"]
+// SomeLongWorkflow -> ["sonamu", "workflow", "some-long-workflow"]
+export function convertDomainToCategory(
+  name: string,
+  type: "model" | "frame" | "agent" | "workflow",
+): readonly string[] {
+  const compareItems = ["class"];
+  if (type !== "workflow") {
+    compareItems.push(type);
+  }
+
+  // SomeAgentClass -> some_agent, SomeModelClass -> some_model, SomeFrameClass -> some_frame
+  const convertedName = inflection
+    .underscore(name)
+    .split("_")
+    .filter((item) => !compareItems.includes(item))
+    .join("-");
+
+  return ["sonamu", type, convertedName];
+}
+
+export function convertNaiteKeyToCategory(key: string): readonly string[] {
+  return key.split(".").flatMap((stem) => stem.split(":"));
+}

package/src/logger/configure.ts

@@ -0,0 +1,132 @@
+import {
+  configure,
+  type Filter,
+  type FilterLike,
+  getConsoleSink,
+  type LoggerConfig,
+  type LogRecord,
+  type Sink,
+  type TextFormatter,
+} from "@logtape/logtape";
+import { getPrettyFormatter } from "@logtape/pretty";
+import type { FastifyReply, FastifyRequest } from "fastify";
+import { isSameCategory } from "./category";
+
+export type SonamuLoggingOptions<TSinkId extends string, TFilterId extends string> = {
+  // fastify 로깅 카테고리 (a.b.c의 형태로 넣으면 [a, b, c]로 들어갑니다.)
+  // 기본값은 ["fastify"] 입니다.
+  fastifyCategory?: readonly string[];
+
+  // 각 항목들을 설정할 때 "fastify-console"이 들어갈 경우, 덮어씌워집니다.
+  sinks?: Record<TSinkId, Sink>;
+  filters?: Record<TFilterId, FilterLike>;
+
+  // 각 항목을 설정할 때 fastifyCategory에 설정된 카테고리가 있을 경우, 기본 logger 설정은 추가되지 않습니다.
+  loggers?: LoggerConfig<TSinkId, TFilterId>[];
+};
+
+// fastify에 대한 기본 sink 설정
+function defaultFastifySink(fastifyCategory: readonly string[]): Sink {
+  const formatter = ((formatter: TextFormatter, record: LogRecord) => {
+    // Fastify API Logger의 경우, 응답 코드와 요청 URL을 추가
+    const filterFastify = (request: FastifyRequest, record: LogRecord, responseCode?: number) => {
+      if (!request.url.startsWith("/api")) {
+        return formatter(record);
+      }
+
+      const lastItem = record.message[record.message.length - 1] as string;
+      return formatter({
+        ...record,
+        message: [
+          ...record.message.slice(0, -1),
+          `[${request.method}${responseCode ? `:${responseCode}` : ""}] ${request.originalUrl} - ${lastItem}`,
+        ],
+      });
+    };
+
+    if (!isSameCategory(fastifyCategory, [...record.category])) {
+      return formatter(record);
+    }
+
+    if ("req" in record.properties && record.properties.req !== null) {
+      const request = record.properties.req as FastifyRequest;
+      return filterFastify(request, record);
+    }
+
+    if ("res" in record.properties && record.properties.res !== null) {
+      const reply = record.properties.res as FastifyReply;
+      return filterFastify(reply.request, record, reply.statusCode);
+    }
+
+    return formatter(record);
+  }).bind(
+    null,
+    getPrettyFormatter({
+      timestamp: "time",
+      categoryWidth: 20,
+      categoryTruncate: "middle",
+    }),
+  );
+
+  return getConsoleSink({
+    formatter,
+  });
+}
+
+// fastify에 대한 기본 filter 설정 (/api 경로의 요청만 로깅)
+function defaultFastifyFilter(fastifyCategory: readonly string[]): Filter {
+  return (record: LogRecord) => {
+    if (!isSameCategory([...fastifyCategory], [...record.category])) {
+      return false;
+    }
+
+    if ("req" in record.properties && record.properties.req !== null) {
+      const request = record.properties.req as FastifyRequest;
+      return request.url.startsWith("/api");
+    }
+
+    if ("res" in record.properties && record.properties.res !== null) {
+      const reply = record.properties.res as FastifyReply;
+      return reply.request.url.startsWith("/api");
+    }
+
+    return true;
+  };
+}
+
+// 전체 logtape 설정
+export async function configureLogTape<TSinkId extends string, TFilterId extends string>(
+  options: SonamuLoggingOptions<TSinkId, TFilterId>,
+) {
+  const fastifyCategory = options.fastifyCategory ?? ["fastify"];
+
+  const sinks = {
+    "fastify-console": defaultFastifySink(fastifyCategory),
+    ...(options.sinks ?? {}),
+  } as Record<TSinkId | "fastify-console", Sink>;
+
+  const filters = {
+    "fastify-console": defaultFastifyFilter(fastifyCategory),
+    ...(options.filters ?? {}),
+  } as Record<TFilterId | "fastify-console", FilterLike>;
+
+  const loggers: Set<LoggerConfig<TSinkId | "fastify-console", TFilterId | "fastify-console">> =
+    new Set(options.loggers ?? []);
+
+  // logtape의 meta logger 표시를 비활성화
+  loggers.add({
+    category: ["logtape", "meta"],
+    lowestLevel: "fatal",
+  });
+
+  if ([...loggers].every((logger) => !isSameCategory([...fastifyCategory], logger.category))) {
+    loggers.add({
+      category: [...fastifyCategory],
+      sinks: ["fastify-console"],
+      lowestLevel: "info",
+      filters: ["fastify-console"],
+    });
+  }
+
+  return configure({ sinks, filters, loggers: [...loggers], reset: true });
+}

package/src/migration/code-generation.ts

@@ -743,7 +743,12 @@ function getAlterIndexesTo(entityIndexes: MigrationIndex[], dbIndexes: Migration
           return undefined;
         }
         if (key === "columns") {
-          return (index[key] as MigrationIndex["columns"]).flatMap(identity);
+          return (index[key] as MigrationIndex["columns"]).map((col) => {
+            return Object.keys(col)
+              .sort()
+              .map((k) => `${k}=${col[k as keyof typeof col]}`)
+              .join("//");
+          });
         }
         return `${key}=${index[key as keyof MigrationIndex]}`;
       })
@@ -776,14 +781,22 @@ function genIndexDropDefinition(index: MigrationIndex) {
 /**
  * DB 조회 결과와 비교하기 위한 인덱스 기본값 설정
  */
-function setMigrationIndexDefaults(index: MigrationIndex): MigrationIndex {
+export function setMigrationIndexDefaults(index: MigrationIndex): MigrationIndex {
+  const supportsOrdering =
+    index.type !== "hnsw" && // type이 hnsw면 벡터 인덱스
+    index.type !== "ivfflat" && // type이 ivfflat면 벡터 인덱스
+    (!index.using || index.using === "btree"); // using 체크
+
   return {
     ...index,
     columns: index.columns.map((col) => ({
-      ...col,
-      sortOrder: col.sortOrder ?? "ASC",
-      // sortOrder에 따라 nullsFirst의 default 값 설정
-      nullsFirst: col.nullsFirst ?? col.sortOrder === "DESC",
+      name: col.name,
+      ...(supportsOrdering
+        ? {
+            sortOrder: col.sortOrder ?? "ASC",
+            nullsFirst: col.nullsFirst ?? col.sortOrder === "DESC",
+          }
+        : {}),
     })),
     nullsNotDistinct: index.nullsNotDistinct ?? false,
     using: index.using ?? "btree",

package/src/migration/migrator.ts

@@ -1,11 +1,12 @@
 import assert from "assert";
 import chalk from "chalk";
 import { mkdir, readdir, unlink, writeFile } from "fs/promises";
-import knex, { type Knex } from "knex";
+import type { Knex } from "knex";
 import path from "path";
 import { group, sum, unique } from "radashi";
 import { Sonamu } from "../api";
 import { DB, type SonamuDBConfig } from "../database/db";
+import { createKnexInstance } from "../database/knex";
 import { EntityManager } from "../entity/entity-manager";
 import { ServiceUnavailableException } from "../exceptions/so-exceptions";
 import { Naite } from "../naite/naite";
@@ -67,7 +68,7 @@ export class Migrator {
     const statuses = await Promise.all(
       connKeys.map(async (connKey) => {
         const knexOptions = Sonamu.dbConfig[connKey];
-        const tConn = knex(knexOptions);
+        const tConn = createKnexInstance(knexOptions);
 
         const status = await (async () => {
           try {
@@ -131,7 +132,7 @@ export class Migrator {
         return [];
       }
 
-      const compareDBconn = knex(Sonamu.dbConfig[status0conn.connKey]);
+      const compareDBconn = createKnexInstance(Sonamu.dbConfig[status0conn.connKey]);
       const genCodes = await this.compareMigrations(compareDBconn);
 
       await compareDBconn.destroy();
@@ -184,7 +185,7 @@ export class Migrator {
     const conns = await Promise.all(
       configs.map(async (config) => ({
         connKey: config.connKey,
-        knex: knex(config.options),
+        knex: createKnexInstance(config.options),
       })),
     );
 
@@ -402,7 +403,7 @@ export class Migrator {
     }
 
     // 기존 Shadow DB 삭제 후 Shadow DB 생성
-    const tdb = knex(Sonamu.dbConfig.test);
+    const tdb = createKnexInstance(Sonamu.dbConfig.test);
     !isTest() && console.log(chalk.magenta(`${shadowDatabase} 삭제`));
     await tdb.raw(`DROP DATABASE IF EXISTS ${shadowDatabase}`);
     await tdb.raw(`
@@ -414,7 +415,7 @@ export class Migrator {
     await tdb.raw(`CREATE DATABASE ${shadowDatabase} TEMPLATE ${tdbConn.database}`);
 
     // Shadow DB에 연결
-    const sdb = knex({
+    const sdb = createKnexInstance({
       ...Sonamu.dbConfig.test,
       connection: {
         ...tdbConn,

package/src/migration/postgresql-schema-reader.ts

@@ -144,9 +144,14 @@ class PostgreSQLSchemaReaderClass {
         name: indexName,
         columns: currentIndexes.map((idx) => ({
           name: idx.column_name,
-          nullsFirst: idx.nulls_first,
-          sortOrder: idx.sort_order,
+          ...(firstIndex.index_type === "btree"
+            ? {
+                sortOrder: idx.sort_order,
+                nullsFirst: idx.nulls_first,
+              }
+            : {}),
         })),
+
         nullsNotDistinct: firstIndex.nulls_not_distinct,
         using: firstIndex.index_type as "btree" | "hash" | "gin" | "gist" | "pgroonga" | undefined,
       };

package/src/naite/naite.ts

@@ -1,8 +1,10 @@
 /** biome-ignore-all lint/suspicious/noExplicitAny: Naite는 expect와 호응하도록 any를 허용함 */
 
+import { getLogger } from "@logtape/logtape";
 import { get } from "radashi";
 import { Sonamu } from "../api/sonamu";
 import type { ComparisonOperator } from "../database/puri.types";
+import { convertNaiteKeyToCategory } from "../logger/category";
 import { isSerializable } from "../utils/object-utils";
 
 // StackFrame 타입
@@ -267,6 +269,14 @@ export class NaiteClass {
 
       // 항상 배열로 관리
       const existing = store.get(name) ?? [];
+      getLogger(["naite", ...convertNaiteKeyToCategory(name)]).debug(
+        `naite: {name} ${existing.length === 0 ? "is empty state" : `already existing with ${existing.length === 0} entries`}, appending new entry`,
+        {
+          name,
+          value,
+        },
+      );
+
       store.set(name, [...existing, trace]);
     } catch {
       // Context 없는 상황에서 Naite.t 호출
@@ -392,24 +402,6 @@ export class NaiteClass {
   createStore(): NaiteStore {
     return new Map<string, NaiteTrace[]>();
   }
-
-  // 일반 로그 레벨
-  d(_message: string) {
-    // TODO: Logger 연결
-    console.log(`[DEBUG] ${_message}`);
-  }
-  i(_message: string) {
-    // TODO: Logger 연결
-    console.log(`[INFO] ${_message}`);
-  }
-  w(_message: string) {
-    // TODO: Logger 연결
-    console.log(`[WARN] ${_message}`);
-  }
-  e(_message: string) {
-    // TODO: Logger 연결
-    console.log(`[ERROR] ${_message}`);
-  }
 }
 
 export const Naite = new NaiteClass();

package/src/shared/web.shared.ts.txt

@@ -10,7 +10,7 @@ import qs from "qs";
 import { type core, z } from "zod";
 
 // ISO 8601 및 타임존 포맷의 날짜 문자열을 Date 객체로 변환하는 reviver
-function dateReviver(_key: string, value: any): any {
+export function dateReviver(_key: string, value: any): any {
   if (typeof value === "string") {
     // ISO 8601 형식: 2024-01-15T09:30:00.000Z 또는 2024-01-15T09:30:00+09:00
     const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{1,3})?)?(Z|[+-]\d{2}:\d{2})?$/;

package/src/ssr/index.ts

@@ -0,0 +1,13 @@
+export {
+  clearSSRRoutes,
+  getSSRRoutes,
+  matchSSRRoute,
+  registerSSR,
+} from "./registry";
+export { renderSSR } from "./renderer";
+export type {
+  PreloadConfig,
+  PreloadedData,
+  SSRQuery,
+  SSRRoute,
+} from "./types";