swallowkit 1.0.0-beta.6 → 1.0.0-beta.60

package/src/database/client.ts

@@ -0,0 +1,140 @@
+import { CosmosClient, Database, Container } from "@azure/cosmos";
+import { SwallowKitConfig } from "../types/index.js";
+import { ensureServerSide } from "./runtime-check.js";
+
+/**
+ * Cosmos DB クライアントの管理
+ */
+export class DatabaseClient {
+  private client: CosmosClient | null = null;
+  private database: Database | null = null;
+  private containers: Map<string, Container> = new Map();
+
+  constructor(private config: SwallowKitConfig) {}
+
+  /**
+   * データベースに接続
+   */
+  async connect(): Promise<void> {
+    ensureServerSide('Database connection');
+
+    if (!this.config.database?.connectionString) {
+      throw new Error("Cosmos DB connection string が設定されていません");
+    }
+
+    this.client = new CosmosClient(this.config.database.connectionString);
+    
+    const databaseName = this.config.database.databaseName || "SwallowKitDB";
+    const { database } = await this.client.databases.createIfNotExists({
+      id: databaseName,
+    });
+    
+    this.database = database;
+    console.log(`📦 Cosmos DB に接続しました: ${databaseName}`);
+  }
+
+  /**
+   * コンテナを取得
+   */
+  async getContainer(containerName: string): Promise<Container> {
+    ensureServerSide('Get container');
+
+    if (!this.database) {
+      await this.connect();
+    }
+
+    if (!this.containers.has(containerName)) {
+      const { container } = await this.database!.containers.createIfNotExists({
+        id: containerName,
+        partitionKey: "/id",
+      });
+      this.containers.set(containerName, container);
+    }
+
+    return this.containers.get(containerName)!;
+  }
+
+  /**
+   * ドキュメントを作成
+   */
+  async createDocument<T extends Record<string, any>>(containerName: string, document: T): Promise<T> {
+    ensureServerSide('Create document');
+
+    const container = await this.getContainer(containerName);
+    const { resource } = await container.items.create(document as any);
+    return resource as T;
+  }
+
+  /**
+   * ドキュメントを取得
+   */
+  async getDocument<T extends Record<string, any>>(containerName: string, id: string): Promise<T | null> {
+    ensureServerSide('Get document');
+
+    const container = await this.getContainer(containerName);
+    
+    try {
+      const { resource } = await container.item(id, id).read();
+      return resource as T || null;
+    } catch (error: any) {
+      if (error.code === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * ドキュメントを更新
+   */
+  async updateDocument<T extends Record<string, any>>(containerName: string, document: T): Promise<T> {
+    ensureServerSide('Update document');
+
+    const container = await this.getContainer(containerName);
+    const { resource } = await container.items.upsert(document as any);
+    return resource as unknown as T;
+  }
+
+  /**
+   * ドキュメントを削除
+   */
+  async deleteDocument(containerName: string, id: string): Promise<void> {
+    ensureServerSide('Delete document');
+
+    const container = await this.getContainer(containerName);
+    await container.item(id, id).delete();
+  }
+
+  /**
+   * クエリを実行
+   */
+  async query<T>(containerName: string, query: string, parameters?: any[]): Promise<T[]> {
+    ensureServerSide('Query');
+
+    const container = await this.getContainer(containerName);
+    const { resources } = await container.items.query<T>({
+      query,
+      parameters,
+    }).fetchAll();
+    
+    return resources;
+  }
+}
+
+/**
+ * グローバルデータベースクライアント
+ */
+let globalDatabaseClient: DatabaseClient | null = null;
+
+export function getDatabaseClient(config?: SwallowKitConfig): DatabaseClient {
+  if (!globalDatabaseClient) {
+    if (!config) {
+      throw new Error(
+        "DatabaseClient is not initialized. " +
+        "Please provide a config or initialize it first."
+      );
+    }
+    globalDatabaseClient = new DatabaseClient(config);
+  }
+  return globalDatabaseClient;
+}

package/src/database/repository.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { getDatabaseClient } from "./client";
+
+/**
+ * Zodスキーマベースのデータベース操作ヘルパー
+ */
+export class SchemaRepository<T extends Record<string, any>> {
+  constructor(
+    private containerName: string,
+    private schema: z.ZodSchema<T>
+  ) {}
+
+  /**
+   * ドキュメントを作成（バリデーション付き）
+   */
+  async create(data: T): Promise<T> {
+    const validatedData = this.schema.parse(data);
+    const client = getDatabaseClient();
+    return client.createDocument(this.containerName, validatedData);
+  }
+
+  /**
+   * ドキュメントを取得
+   */
+  async findById(id: string): Promise<T | null> {
+    const client = getDatabaseClient();
+    const document = await client.getDocument<T>(this.containerName, id);
+    
+    if (!document) return null;
+    
+    // データをバリデーション
+    return this.schema.parse(document);
+  }
+
+  /**
+   * ドキュメントを更新（バリデーション付き）
+   */
+  async update(data: T): Promise<T> {
+    const validatedData = this.schema.parse(data);
+    const client = getDatabaseClient();
+    return client.updateDocument(this.containerName, validatedData);
+  }
+
+  /**
+   * ドキュメントを削除
+   */
+  async delete(id: string): Promise<void> {
+    const client = getDatabaseClient();
+    return client.deleteDocument(this.containerName, id);
+  }
+
+  /**
+   * 全てのドキュメントを取得
+   */
+  async findAll(): Promise<T[]> {
+    const client = getDatabaseClient();
+    const documents = await client.query<T>(
+      this.containerName,
+      "SELECT * FROM c"
+    );
+    
+    // 全てのドキュメントをバリデーション
+    return documents.map(doc => this.schema.parse(doc));
+  }
+
+  /**
+   * 条件付きクエリ
+   */
+  async findWhere(condition: string, parameters?: any[]): Promise<T[]> {
+    const client = getDatabaseClient();
+    const query = `SELECT * FROM c WHERE ${condition}`;
+    const documents = await client.query<T>(this.containerName, query, parameters);
+    
+    return documents.map(doc => this.schema.parse(doc));
+  }
+}
+
+/**
+ * 簡単なリポジトリ作成ヘルパー
+ */
+export function createRepository<T extends Record<string, any>>(
+  containerName: string,
+  schema: z.ZodSchema<T>
+): SchemaRepository<T> {
+  return new SchemaRepository(containerName, schema);
+}
+
+/**
+ * よく使われるスキーマの例
+ */
+export const TodoSchema = z.object({
+  id: z.string(),
+  text: z.string(),
+  completed: z.boolean().default(false),
+  createdAt: z.string().default(() => new Date().toISOString()),
+  updatedAt: z.string().default(() => new Date().toISOString()),
+});
+
+export type Todo = z.infer<typeof TodoSchema>;
+
+/**
+ * Todo専用リポジトリの例
+ */
+export const TodoRepository = createRepository("todos", TodoSchema);

package/src/database/runtime-check.ts

@@ -0,0 +1,25 @@
+/**
+ * ランタイム環境の検証
+ * クライアント側でのDB操作を防ぐ
+ */
+
+/**
+ * サーバー側で実行されているかチェック
+ */
+export function isServer(): boolean {
+  return typeof window === 'undefined';
+}
+
+/**
+ * サーバー側での実行を強制
+ * クライアント側で呼ばれた場合はエラーを投げる
+ */
+export function ensureServerSide(operationName: string = 'Database operation'): void {
+  if (!isServer()) {
+    throw new Error(
+      `${operationName} can only be executed on the server side. ` +
+      `Please use this within Server Components, Server Actions, or API Routes. ` +
+      `Client Components cannot directly access the database.`
+    );
+  }
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+/**
+ * SwallowKit - Next.js framework optimized for Azure deployment
+ * Main exports
+ */
+
+// Type definitions
+export type {
+  UseServerFnOptions,
+  UseServerFnResult,
+  ServerFnMode,
+  BackendLanguage,
+  SwallowKitConfig,
+} from "./types";
+
+// Configuration
+export {
+  loadConfig,
+  generateConfig,
+  getBackendLanguage,
+  getFullConfig,
+  validateConfig,
+} from "./core/config";
+
+// Database - Zod-based schema sharing between frontend, backend, and Cosmos DB
+export { DatabaseClient, getDatabaseClient } from "./database/client";
+export { SchemaRepository, createRepository, TodoSchema, TodoRepository } from "./database/repository";
+export type { Todo } from "./database/repository";

package/src/machine/contracts.ts

@@ -0,0 +1,33 @@
+export type MachineOperationStatus =
+  | "complete"
+  | "in-progress"
+  | "blocked"
+  | "requires-human"
+  | "unsafe"
+  | "failed";
+
+export interface MachineNextAction {
+  command: string;
+  description: string;
+}
+
+export interface MachineSuccessResponse<TData> {
+  ok: true;
+  command: string;
+  status?: MachineOperationStatus;
+  nextActions?: MachineNextAction[];
+  data: TData;
+}
+
+export interface MachineErrorResponse {
+  ok: false;
+  command: string;
+  status?: MachineOperationStatus;
+  error: {
+    code: string;
+    message: string;
+    details?: unknown;
+  };
+}
+
+export type MachineResponse<TData> = MachineSuccessResponse<TData> | MachineErrorResponse;

package/src/machine/errors.ts

@@ -0,0 +1,45 @@
+import type { MachineOperationStatus } from "./contracts";
+
+export class MachineCommandError extends Error {
+  readonly code: string;
+  readonly details?: unknown;
+  readonly status?: MachineOperationStatus;
+
+  constructor(code: string, message: string, details?: unknown, status?: MachineOperationStatus) {
+    super(message);
+    this.name = "MachineCommandError";
+    this.code = code;
+    this.details = details;
+    this.status = status;
+  }
+}
+
+export function resolveMachineErrorStatus(error: unknown): MachineOperationStatus {
+  if (error instanceof MachineCommandError && error.status) {
+    return error.status;
+  }
+  return "failed";
+}
+
+export function toMachineError(error: unknown): { code: string; message: string; details?: unknown } {
+  if (error instanceof MachineCommandError) {
+    return {
+      code: error.code,
+      message: error.message,
+      ...(error.details === undefined ? {} : { details: error.details }),
+    };
+  }
+
+  if (error instanceof Error) {
+    return {
+      code: "internal-error",
+      message: error.message,
+    };
+  }
+
+  return {
+    code: "internal-error",
+    message: "Unknown error",
+    details: error,
+  };
+}