@gencow/core 0.1.27 → 0.1.29

package/src/runtime-env-policy.ts

@@ -0,0 +1,66 @@
+const RESERVED_TENANT_RUNTIME_ENV_KEYS = new Set([
+  "PORT",
+  "DATABASE_URL",
+  "GENCOW_DB_URL",
+  "BETTER_AUTH_SECRET",
+  "BETTER_AUTH_URL",
+  "IS_PLATFORM",
+  "GENCOW_PLATFORM_CONFIG_FILE",
+  "GENCOW_PLATFORM_URL",
+  "GENCOW_PLATFORM_DB",
+  "PLATFORM_OPENAI_KEY",
+  "PLATFORM_GOOGLE_KEY",
+  "PLATFORM_INTERNAL_SECRET",
+  "INVITE_ONLY",
+  "RUNNER_TYPE",
+  "PGBOUNCER_PORT",
+  "GENCOW_FUNCTIONS",
+  "GENCOW_STORAGE",
+  "GENCOW_MIGRATIONS",
+  "GENCOW_APP_NAME",
+  "GENCOW_APP_DATA_DIR",
+  "GENCOW_INTERNAL_TOKEN",
+  "GENCOW_CRON_TOKEN",
+  "GENCOW_AI_PROXY_URL",
+  "GENCOW_AI_PROXY_URL_ALT",
+  "GENCOW_AI_PROXY_TOKEN",
+  "GENCOW_METERING_URL",
+  "GENCOW_METERING_URL_ALT",
+  "GENCOW_START_REASON",
+  "GENCOW_RESTART_ID",
+  "GENCOW_SHUTDOWN_MARKER_PATH",
+  "GENCOW_SKIP_MIGRATION",
+  "GENCOW_DB_MAX_CONNECTIONS",
+  "GENCOW_MEMORY_MB",
+  "BUN_JSC_forceRAMSize",
+  "MIMALLOC_PURGE_DELAY",
+  "NODE_PATH",
+]);
+
+const RESERVED_TENANT_RUNTIME_ENV_PREFIXES = ["__GENCOW_", "GENCOW_DOCUMENT_", "GENCOW_TEMPLATE_", "GENCOW_WARM_"];
+
+export function isReservedTenantRuntimeEnvKey(key: string): boolean {
+  const normalized = key.trim();
+  return (
+    RESERVED_TENANT_RUNTIME_ENV_KEYS.has(normalized) ||
+    RESERVED_TENANT_RUNTIME_ENV_PREFIXES.some((prefix) => normalized.startsWith(prefix))
+  );
+}
+
+export function filterTenantRuntimeEnvVars(vars: Record<string, string>): {
+  allowed: Record<string, string>;
+  rejectedKeys: string[];
+} {
+  const allowed: Record<string, string> = {};
+  const rejectedKeys: string[] = [];
+
+  for (const [key, value] of Object.entries(vars)) {
+    if (isReservedTenantRuntimeEnvKey(key)) {
+      rejectedKeys.push(key);
+      continue;
+    }
+    allowed[key] = value;
+  }
+
+  return { allowed, rejectedKeys };
+}

package/src/search-types.ts

@@ -0,0 +1,91 @@
+export type SearchPrimitive = string | number | boolean;
+
+export type SearchScope = {
+  corpus: string;
+  visibility: "private" | "shared" | "public";
+  ownerUserId?: string;
+};
+
+export type SearchFilter = {
+  eq?: Record<string, SearchPrimitive>;
+  in?: Record<string, SearchPrimitive[]>;
+  range?: Record<string, { gte?: string | number; lte?: string | number }>;
+};
+
+export type SearchOptions = {
+  fields: [string, ...string[]];
+  limit?: number;
+  offset?: number;
+  filters?: SearchFilter;
+  scope: SearchScope;
+};
+
+export type VectorSearchTuning = {
+  minScore?: number;
+};
+
+export type VectorSearchOptions = Omit<SearchOptions, "fields"> & {
+  vector: number[];
+  vectorField?: string;
+  tuning?: VectorSearchTuning;
+};
+
+export type HybridSearchFusionTuning = {
+  mode?: "rrf";
+  rrfK?: number;
+  keywordWeight?: number;
+  vectorWeight?: number;
+};
+
+export type HybridSearchTuning = {
+  keywordCandidateLimit?: number;
+  vectorCandidateLimit?: number;
+  minFusedScore?: number;
+  fusion?: HybridSearchFusionTuning;
+};
+
+export type HybridSearchOptions = SearchOptions & {
+  vector: number[];
+  vectorField?: string;
+  fusion?: "rrf"; // legacy top-level compatibility
+  keywordCandidateLimit?: number; // legacy top-level compatibility
+  vectorCandidateLimit?: number; // legacy top-level compatibility
+  tuning?: HybridSearchTuning;
+};
+
+export type SearchHit = {
+  id: string | number;
+  row: Record<string, unknown>;
+  score: number;
+  scores?: {
+    keyword?: number;
+    vector?: number;
+    fused?: number;
+  };
+  matchedBy: Array<"keyword" | "vector">;
+};
+
+export type SearchResponse = {
+  items: SearchHit[];
+  meta: {
+    engine: "tsvector" | "pgroonga";
+    tier: "free" | "pro" | "scale";
+    limit: number;
+    offset: number;
+    nextOffset?: number;
+    fusion?: "rrf";
+    mode?: "keyword" | "vector" | "hybrid";
+  };
+};
+
+export type SearchTierConfig = {
+  plan: "free" | "pro" | "scale";
+  engine: "tsvector" | "pgroonga";
+  hybridSearch: boolean;
+  locale: "english" | "multilingual";
+  extensions: {
+    vector: boolean;
+    pgroonga: boolean;
+  };
+  degradedReason?: string;
+};

package/src/server.ts

@@ -6,6 +6,10 @@
  * bundled into user functions which run in Firecracker.
  */
 export { createStorage, storageRoutes } from "./storage.js";
-export type { StorageImageTierConfig } from "./storage.js";
+export type {
+  StorageImageTierConfig,
+  StorageImageTransformMetric,
+  StorageMeteringOptions,
+  StoredFile,
+} from "./storage.js";
 export { createScheduler, getSchedulerInfo } from "./scheduler.js";
-export { authMiddleware, authRoutes, getUsers } from "./auth.js";

package/src/storage-metering.ts

@@ -0,0 +1,35 @@
+import * as fs from "fs/promises";
+
+export interface StorageImageTransformMetric {
+  transformCount: number;
+  sourceBytes: number;
+  outputBytes: number;
+  format: string;
+  autoWebp: boolean;
+}
+
+export interface StorageMeteringOptions {
+  onImageTransform?: (metric: StorageImageTransformMetric) => void | Promise<void>;
+}
+
+export async function recordStorageImageTransform(
+  options: StorageMeteringOptions | undefined,
+  cachePath: string,
+  metric: Omit<StorageImageTransformMetric, "transformCount" | "outputBytes">,
+): Promise<{ size: number }> {
+  const stats = await fs.stat(cachePath);
+  if (!options?.onImageTransform) return stats;
+
+  try {
+    await options.onImageTransform({
+      ...metric,
+      transformCount: 1,
+      outputBytes: stats.size,
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.warn(`[storage] image transform metering failed: ${msg.slice(0, 120)}`);
+  }
+
+  return stats;
+}

package/src/storage-shared.ts

@@ -0,0 +1,74 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+
+/** 파일 업로드 최대 크기: 50MB (하드코딩 — 사용자가 오버라이드 불가) */
+export const MAX_FILE_SIZE = 50 * 1024 * 1024;
+
+/** 기본 스토리지 쿼터: 1GB */
+export const DEFAULT_STORAGE_QUOTA = 1024 * 1024 * 1024;
+
+export interface StorageFile {
+  id: string;
+  name: string;
+  size: number;
+  type: string;
+  path: string;
+}
+
+export interface StoredFile {
+  id: string;
+  name: string;
+  size: number;
+  type: string;
+  buffer: Buffer;
+}
+
+export interface StorageOptions {
+  rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>;
+  storageQuota?: number;
+}
+
+export interface Storage {
+  store(file: File | Blob, filename?: string): Promise<string>;
+  storeBuffer(buffer: Buffer, filename: string, type?: string): Promise<string>;
+  get(storageId: string): Promise<StoredFile | null>;
+  getUrl(storageId: string): string;
+  getMeta(storageId: string): Promise<StorageFile | null>;
+  delete(storageId: string): Promise<void>;
+}
+
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
+}
+
+export async function loadStorageMeta(params: {
+  storageId: string;
+  dir: string;
+  metaStore: Map<string, StorageFile>;
+}): Promise<StorageFile | null> {
+  const cached = params.metaStore.get(params.storageId);
+  if (cached) {
+    return cached;
+  }
+
+  const filePath = path.join(params.dir, params.storageId);
+  try {
+    const raw = await fs.readFile(`${filePath}.meta`, "utf-8");
+    const parsed = JSON.parse(raw) as { name?: unknown; type?: unknown; size?: unknown };
+    const stat = await fs.stat(filePath);
+    const meta: StorageFile = {
+      id: params.storageId,
+      name: typeof parsed.name === "string" ? parsed.name : params.storageId,
+      size: typeof parsed.size === "number" ? parsed.size : stat.size,
+      type: typeof parsed.type === "string" ? parsed.type : "application/octet-stream",
+      path: filePath,
+    };
+    params.metaStore.set(params.storageId, meta);
+    return meta;
+  } catch {
+    return null;
+  }
+}

package/src/storage.ts

@@ -2,51 +2,18 @@ import * as fs from "fs/promises";
 import * as fsSync from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
-
-// ─── Constants ──────────────────────────────────────────
-
-/** 파일 업로드 최대 크기: 50MB (하드코딩 — 사용자가 오버라이드 불가) */
-const MAX_FILE_SIZE = 50 * 1024 * 1024;
-
-/** 기본 스토리지 쿼터: 1GB */
-const DEFAULT_STORAGE_QUOTA = 1024 * 1024 * 1024;
-
-function formatBytes(bytes: number): string {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
-}
-
-// ─── Types ──────────────────────────────────────────────
-
-interface StorageFile {
-  id: string;
-  name: string;
-  size: number;
-  type: string;
-  path: string;
-}
-
-export interface StorageOptions {
-  /** Raw SQL 실행 함수 — DB 자동 기록 + 쿼터 검증에 필요 */
-  rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>;
-  /** 앱별 스토리지 쿼터 (bytes). 0 = 무제한. 기본: 1GB */
-  storageQuota?: number;
-}
-
-export interface Storage {
-  /** Store a file and return a storageId — Convex의 ctx.storage.store() */
-  store(file: File | Blob, filename?: string): Promise<string>;
-  /** Store from raw buffer */
-  storeBuffer(buffer: Buffer, filename: string, type?: string): Promise<string>;
-  /** Get a serving URL for the file — Convex의 ctx.storage.getUrl() */
-  getUrl(storageId: string): string;
-  /** Get file metadata */
-  getMeta(storageId: string): Promise<StorageFile | null>;
-  /** Delete a stored file — Convex의 ctx.storage.delete() */
-  delete(storageId: string): Promise<void>;
-}
+import {
+  DEFAULT_STORAGE_QUOTA,
+  MAX_FILE_SIZE,
+  formatBytes,
+  loadStorageMeta,
+} from "./storage-shared.js";
+import type { Storage, StorageFile, StorageOptions, StoredFile } from "./storage-shared.js";
+import { recordStorageImageTransform } from "./storage-metering.js";
+import type { StorageMeteringOptions } from "./storage-metering.js";
+
+export type { Storage, StorageFile, StorageOptions, StoredFile } from "./storage-shared.js";
+export type { StorageImageTransformMetric, StorageMeteringOptions } from "./storage-metering.js";
 
 // ─── Implementation ─────────────────────────────────────
 
@@ -96,6 +63,8 @@ async function checkStorageQuota(
 ): Promise<void> {
   if (quota <= 0) return; // 무제한
 
+  await ensureFilesTable(rawSql);
+
   const rows = await rawSql(`SELECT COALESCE(SUM(CAST(size AS BIGINT)), 0) AS total FROM _system_files`);
   const currentUsage = Number((rows[0] as Record<string, string>)?.total || "0");
   const projectedUsage = currentUsage + newFileSize;
@@ -147,7 +116,6 @@ export function createStorage(dir: string = "./uploads", options?: StorageOption
 
   // Ensure directory exists
   fs.mkdir(dir, { recursive: true }).catch(() => {});
-
   return {
     async store(file: File | Blob, filename?: string): Promise<string> {
       // 크기 제한 검증 (단일 파일)
@@ -248,8 +216,28 @@ export function createStorage(dir: string = "./uploads", options?: StorageOption
       return `/api/storage/${storageId}`;
     },
 
+    async get(storageId: string): Promise<StoredFile | null> {
+      const meta = await loadStorageMeta({ storageId, dir, metaStore });
+      if (!meta) {
+        return null;
+      }
+
+      const buffer = await fs.readFile(meta.path).catch(() => null);
+      if (!buffer) {
+        return null;
+      }
+
+      return {
+        id: meta.id,
+        name: meta.name,
+        size: meta.size,
+        type: meta.type,
+        buffer,
+      };
+    },
+
     async getMeta(storageId: string): Promise<StorageFile | null> {
-      return metaStore.get(storageId) || null;
+      return loadStorageMeta({ storageId, dir, metaStore });
     },
 
     async delete(storageId: string): Promise<void> {
@@ -482,6 +470,7 @@ export function storageRoutes(
   rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>,
   storageDir?: string,
   tierConfig?: StorageImageTierConfig,
+  meteringOptions?: StorageMeteringOptions,
 ) {
   const baseTierConfig: Required<StorageImageTierConfig> = {
     autoWebp: tierConfig?.autoWebp ?? true,
@@ -753,15 +742,17 @@ export function storageRoutes(
 
         // 변환 실행 → 캐시에 저장
         await pipeline.toFile(cachePath);
+        const cacheStats = await recordStorageImageTransform(meteringOptions, cachePath, {
+          sourceBytes: meta.size,
+          format: outputFormat || meta.type.replace(/^image\//, ""),
+          autoWebp: isAutoWebp,
+        });
 
         // WebP/AVIF가 원본보다 큰 경우 → 캐시 삭제 + 원본 서빙
         // (Static Deploy와 동일 전략 — apps.ts L840-847)
-        if (isAutoWebp) {
-          const cacheStats = await fs.stat(cachePath);
-          if (cacheStats.size >= meta.size) {
-            await fs.unlink(cachePath).catch(() => {});
-            return serveOriginal(c, meta);
-          }
+        if (isAutoWebp && cacheStats.size >= meta.size) {
+          await fs.unlink(cachePath).catch(() => {});
+          return serveOriginal(c, meta);
         }
 
         return serveCachedFile(c, cachePath, transformParams, isAutoWebp, meta);

package/src/wake-app-result.ts

@@ -0,0 +1,37 @@
+export type WakeAppSuccessStatus = "already_running" | "woke";
+export type WakeAppDeferredStatus = "capacity_rejected" | "queue_timeout";
+
+export type WakeAppSuccessResult = {
+  ok: true;
+  status: WakeAppSuccessStatus;
+  port: number;
+};
+
+export type WakeAppDeferredResult = {
+  ok: false;
+  status: WakeAppDeferredStatus;
+  retryAfterSec: number;
+};
+
+export type WakeAppBootFailedResult = {
+  ok: false;
+  status: "boot_failed";
+  error: string;
+};
+
+export type WakeAppResult = WakeAppSuccessResult | WakeAppDeferredResult | WakeAppBootFailedResult;
+
+export const DEFAULT_WAKE_RETRY_AFTER_SEC = 30;
+
+export function buildWakeAppSuccessResult(status: WakeAppSuccessStatus, port: number): WakeAppSuccessResult {
+  return { ok: true, status, port };
+}
+
+export function buildWakeAppBootFailedResult(error: unknown): WakeAppBootFailedResult {
+  const message = error instanceof Error ? error.message : String(error);
+  return { ok: false, status: "boot_failed", error: message };
+}
+
+export function isWakeAppDeferredResult(result: WakeAppResult): result is WakeAppDeferredResult {
+  return !result.ok && (result.status === "capacity_rejected" || result.status === "queue_timeout");
+}

package/src/workflow-types.ts

@@ -1,4 +1,5 @@
-import type { GencowCtx } from "./reactive.js";
+import type { GencowCtx } from "./context.js";
+import type { WorkflowDocumentServicesCtx } from "./document-types.js";
 import type { InferArgs } from "./v.js";
 
 export type WorkflowStatus = "pending" | "running" | "completed" | "failed";
@@ -28,6 +29,7 @@ export interface WorkflowSummary {
   derivedStatus: WorkflowDerivedStatus;
   currentStep: string | null;
   error: string | null;
+  errorCode: string | null;
   retryCount: number;
   maxRetries: number;
   maxDurationMs: number;
@@ -77,9 +79,13 @@ export interface WorkflowResumePayload {
   workflowId: string;
 }
 
-export interface WorkflowCtx extends GencowCtx {
+export interface WorkflowCtx extends Omit<GencowCtx, "services"> {
   workflowId: string;
   workflowName: string;
+  runId?: string;
+  attempt?: number;
+  stepAttempt?: number;
+  services: GencowCtx["services"] & WorkflowDocumentServicesCtx;
   step<TResult>(name: string, run: () => Promise<TResult>): Promise<TResult>;
   sleep(duration: WorkflowDuration): Promise<void>;
   waitForEvent<TPayload = unknown>(name: string, timeout?: WorkflowDuration): Promise<TPayload>;
@@ -93,7 +99,11 @@ export type WorkflowHandler<TArgs, TReturn> = (wf: WorkflowCtx, args: TArgs) =>
 export interface WorkflowOptions<TSchema = any, TReturn = any> {
   args?: TSchema;
   public?: boolean;
+  version?: string;
   maxDuration?: WorkflowDuration;
+  maxActiveDuration?: WorkflowDuration;
+  lifecycleTimeout?: WorkflowDuration;
+  concurrency?: number;
   retries?: number;
   handler: WorkflowHandler<InferArgs<TSchema>, TReturn>;
 }
@@ -102,7 +112,11 @@ export interface WorkflowDef<TSchema = any, TReturn = any> {
   name: string;
   argsSchema?: TSchema;
   isPublic: boolean;
+  version?: string;
   maxDurationMs: number;
+  maxActiveDurationMs: number;
+  lifecycleTimeoutMs: number | null;
+  concurrency: number | null;
   maxRetries: number;
   handler: WorkflowHandler<InferArgs<TSchema>, TReturn>;
 }