node-riner 1.3.1 → 2.0.0

package/README.md

@@ -1,28 +1,85 @@
-# Ride Framework
+# Riner Framework (Node Riner)
 
-XMLファイルをベースに動的なHTMLページを生成し、Expressサーバーとして配信する軽量なSSR（Server-Side Rendering）ユーティリティです。
+Rinerは独自のファイルをhtmlに変換し、Expressサーバーで配信します。
 
-## 📦 インストール
-
-プロジェクトのルートディレクトリで以下のコマンドを実行してください。
+## インストール
 
 ```bash
 npm i node-riner@latest
 ```
-## Example
-index.rd
-``` RideFrameworks
+
+## 特長（主な機能）
+
+- RinerRideFile(.rd) から HTML を自動生成して Express で配信
+- `{ ... }` 内の JavaScript をサンドボックス実行して動的に値を埋め込み
+- 永続状態管理 riner.state（サーバ側に保存）
+- 永続的に実行される move（riner.move）を登録して state を更新
+- riner.out / riner.move / riner.off / riner.clear をテンプレートから利用可能
+- SSE（Server-Sent Events）で state の変更をクライアントに配信
+- REST API で state / moves の取得・更新が可能
+
+## 使い方（最小構成）
+
+index.rd（XML）
+```xml
 <Root>
-   <Page route="/">
-      <h1>hello world</h1>
-   </Page>
+  <Page route="/">
+    <Content>
+      <h1>Hello</h1>
+      <p>{riner.out(new Date().toString())}</p>
+    </Content>
+  </Page>
 </Root>
 ```
+
 main.ts
-```
+```ts
 import Riner from 'node-riner'
 
-let App = new Riner("my app")
-App.Ride("index.rd")
-App.serve(3000)
+const app = new Riner('my app')
+app.Ride('index.rd')      // XML を読み込む
+app.config({ siteName: 'MyBlog' }) // サーバ側既定コンテキスト
+app.serve(3000)           // サーバ起動
+```
+
+## riner API（テンプレート内で使用）
+
+- riner.out(...args) — 出力を収集して文字列化して埋め込む  
+- riner.move(fn) — 永続的な move を登録（fn は関数。例: () => counter = (counter||0)+1）  
+- riner.off(fnOrSrc) — 指定した move を解除（関数かソース文字列で指定）  
+- riner.clear() — 全ての move を削除  
+- riner.state — サーバ保存の state オブジェクトへ参照
+
+テンプレート例:
+```xml
+<p>{riner.out(counter)}</p>
+<p>{riner.move(() => counter = (counter || 0) + 1)}</p>
+```
+
+## サーバ側 API / SSE
+
+- GET  /__riner/state        — 現在の riner.state を返す（JSON）
+- POST /__riner/state        — JSON を送って state をマージ
+- GET  /__riner/moves        — 登録中の move 一覧を返す
+- POST /__riner/moves       — { source: "function source" } で move 登録
+- DELETE /__riner/moves     — { source: "function source" } で move 削除
+- SSE  /__riner/events       — state 更新を受け取る（リアルタイム）
+
+## 注意（セキュリティ）
+
+- テンプレート内の `{ ... }` はサンドボックス（vm）で実行しますが、任意コード実行のリスクは完全には無くなりません。  
+- 外部入力や未信頼のテンプレートを評価しないでください。プロダクションでは追加の制限・監査が必須です。
+
+## 例: Test.rd（サンプル）
+
+```xml
+<Root>
+  <Page route="/">
+    <Content>
+      <h1>My Blog</h1>
+      <p>{riner.out(new Date().toString())}</p>
+      <p>訪問回数: {riner.out(counter)}</p>
+    </Content>
+  </Page>
+</Root>
 ```

package/index.ts

@@ -1,9 +1,9 @@
-// ...existing code...
 import fs, { readFileSync, writeFileSync } from 'fs'
 import { XMLParser } from 'fast-xml-parser'
 import exp from 'express'
 import path from 'path'
 import { execSync } from 'node:child_process'
+import { runInNewContext } from 'vm'
 
 /**
  * Ride クラス
@@ -12,45 +12,137 @@ export default class Ride {
     F: string
     parsedJson: any
     pages: Record<string, string>
+    pagesTemplates: Record<string, any>   // ルート => 生の Content オブジェクト（リクエスト毎に評価）
     name: string
     defaultinfo: string
+    defaultContext: any                   // サーバ/アプリ側で渡したい既定のコンテキスト
+
+    // riner 用の持続状態と登録済み move 関数のソース一覧
+    private rinerState: Record<string, any>
+    private rinerMoves: string[]
 
     constructor(name: string) {
         this.F = ""
         this.parsedJson = {}
         this.pages = {}
+        this.pagesTemplates = {}
         this.name = name
         this.defaultinfo = ""
+        this.defaultContext = {}
+        this.rinerState = {}
+        this.rinerMoves = []
+    }
+
+    /**
+     * 保存済み move 関数を sandbox 上で実行し、rinerState を同期する
+     * - ctx はそのまま sandbox に渡す（req 等を参照できるように）
+     * - move 関数内では riner.state または state のように直接変数を参照して変更可能
+     */
+    private runPersistedMoves(ctx: any = {}) {
+        if (!this.rinerMoves.length) return
+
+        // ベース sandbox：ctx をコピー
+        const sandboxBase: Record<string, any> = Object.assign({}, ctx)
+
+        // riner.state とトップレベル変数として現在の rinerState を注入
+        sandboxBase.riner = { state: this.rinerState }
+        Object.keys(this.rinerState).forEach(k => {
+            sandboxBase[k] = this.rinerState[k]
+        })
+
+        // 実行中にエラーが出ても次の move に進める
+        for (const src of this.rinerMoves) {
+            try {
+                // src は関数ソース文字列 (例: "() => cout += 1")
+                // 即時実行して state を更新させる
+                runInNewContext(`(${src})()`, sandboxBase, { timeout: 2000 })
+            } catch (e) {
+                // 失敗は無視（必要ならログを出す）
+                // console.error('move execution error', e)
+            }
+        }
+
+        // sandboxBase のトップレベル変数を rinerState に同期（riner/state は除外）
+        Object.keys(sandboxBase).forEach(k => {
+            if (k === 'riner' || k === 'console' || k === 'req' || k === 'server' || k === 'page' || k === 'data') return
+            this.rinerState[k] = sandboxBase[k]
+        })
     }
 
     /**
      * 値を再帰的に HTML に変換するユーティリティ
-     * - 文字列: `{...}` を評価して置換（既存挙動を維持）
-     * - 配列: 各要素を <item> でラップして連結
-     * - オブジェクト: 各キーをタグ名として再帰的にレンダリング
-     *
-     * 注意: '@_' で始まるキー（属性）はここではタグ化しない。
+     * - ctx を渡すと { ... } 内のコードをそのコンテキストで評価する
+     * - riner.out / riner.move / riner.state を提供
      */
-    private renderValue(value: any): string {
-        // null / undefined
+    private renderValue(value: any, ctx: any = {}): string {
         if (value === null || value === undefined) return ''
 
         // 文字列処理（{...} の評価を含む）
         if (typeof value === 'string') {
-            // 複数マッチにも対応
             const matches = value.match(/{.*?}/g)
             if (matches) {
                 let newValue = value
                 matches.forEach(m => {
-                    const code = m.slice(1, -1) // 中身を取り出す
+                    const code = m.slice(1, -1) // 中身
+
+                    // まず、保存済み move を実行して最新の状態にする
+                    this.runPersistedMoves(ctx)
+
+                    // 出力収集用
+                    const output: string[] = []
+
+                    // sandbox を組み立て：ctx をコピー、riner、そしてトップレベルに rinerState を展開
+                    const sandbox: Record<string, any> = Object.assign({}, ctx)
+
+                    // riner オブジェクト（host 側のメソッドはクロスコンテキストで呼ばれる）
+                    sandbox.riner = {
+                        // 出力を収集するために riner.out を提供
+                        out: (...args: any[]) => output.push(args.map(a => String(a)).join(' ')),
+                        // riner.move は sandbox 内で関数を渡すと、その関数ソースを保存して以降持続的に実行される
+                        move: (fn: Function) => {
+                            try {
+                                const src = fn.toString()
+                                // 重複を避けるため同一ソースは再登録しない
+                                if (!this.rinerMoves.includes(src)) this.rinerMoves.push(src)
+                                return true
+                            } catch (e) {
+                                return false
+                            }
+                        },
+                        // 直接 state にアクセスできるように参照を渡す
+                        state: this.rinerState
+                    }
+
+                    // トップレベルでも直接 state の各キーを参照できるように注入
+                    Object.keys(this.rinerState).forEach(k => {
+                        sandbox[k] = this.rinerState[k]
+                    })
+
+                    // console を簡易的にラップして出力を収集
+                    sandbox.console = {
+                        log: (...args: any[]) => output.push(args.map(a => String(a)).join(' ')),
+                        error: (...args: any[]) => output.push(args.map(a => String(a)).join(' ')),
+                        warn: (...args: any[]) => output.push(args.map(a => String(a)).join(' '))
+                    }
+
+                    // 実行
+                    console.log(sandbox)
+                    console.log(code)
+                    let res: any
                     try {
-                        // 既存の実装を踏襲して runs.js に書き出して node で実行
-                        writeFileSync("./runs.js", code)
-                        const out = execSync("node runs.js").toString()
-                        newValue = newValue.replace(m, out)
+                        res = runInNewContext(code, sandbox, { timeout: 2000 })
                     } catch (e) {
-                        newValue = newValue.replace(m, '')
+                        res = undefined
                     }
+
+                    // sandbox 上で変更されたトップレベル変数を rinerState に反映
+                    Object.keys(sandbox).forEach(k => {
+                        if (k === 'riner' || k === 'console' || k === 'req' || k === 'server' || k === 'page' || k === 'data') return
+                        this.rinerState[k] = sandbox[k]
+                    })
+
+                    const out = output.length ? output.join('\n') : (res !== undefined ? String(res) : '')
+                    newValue = newValue.replace(m, out)
                 })
                 return newValue
             }
@@ -59,74 +151,64 @@ export default class Ride {
 
         // 配列: 各要素を再帰的に処理して <item> でラップ
         if (Array.isArray(value)) {
-            return value.map((item: any) => `<item>${this.renderValue(item)}</item>`).join('')
+            return value.map((item: any) => `<item>${this.renderValue(item, ctx)}</item>`).join('')
         }
 
         // オブジェクト: 属性(@_...) を無視して子要素だけタグ化する
         if (typeof value === 'object') {
             return Object.keys(value)
-                .filter(key => !key.startsWith('@_')) // 属性はここで無視
+                .filter(key => !key.startsWith('@_'))
                 .map(key => {
-                    // テキストノードは直接中身を出力
                     if (key === '#text' || key === '_text') {
-                        return this.renderValue(value[key])
+                        return this.renderValue(value[key], ctx)
                     }
-                    return `<${key}>${this.renderValue(value[key])}</${key}>`
+                    return `<${key}>${this.renderValue(value[key], ctx)}</${key}>`
                 }).join('')
         }
 
-        // その他（数値や真偽値など）はそのまま文字列化
         return String(value)
     }
 
     /**
      * タグ名とその値から、属性を正しく反映した HTML を生成する
-     * - value が配列ならタグを複数分生成
-     * - value がオブジェクトで属性（@_...）を持つ場合、属性を開タグに組み込む
+     * - ctx を渡して { ... } の中で req / server / page / data が参照できる
      */
-    private renderContentTag(tag: string, value: any): string {
-        // 配列の場合は各要素で同じタグを生成
+    private renderContentTag(tag: string, value: any, ctx: any = {}): string {
         if (Array.isArray(value)) {
-            return value.map((item: any) => this.renderContentTag(tag, item)).join('')
+            return value.map((item: any) => this.renderContentTag(tag, item, ctx)).join('')
         }
 
-        // プリミティブ（文字列等）の場合はタグでラップ
         if (value === null || value === undefined || typeof value !== 'object') {
-            return `<${tag}>${this.renderValue(value)}</${tag}>`
+            return `<${tag}>${this.renderValue(value, ctx)}</${tag}>`
         }
 
-        // オブジェクトの場合、属性を抽出
         const entries = Object.entries(value)
         const attrEntries = entries.filter(([k]) => k.startsWith('@_'))
         const childEntries = entries.filter(([k]) => !k.startsWith('@_'))
 
-        // 属性文字列を組み立て（@_ を取り除く）
         const attrs = attrEntries.map(([k, v]) => {
             const name = k.replace(/^@_/, '')
             const safe = String(v).replace(/"/g, '&quot;')
             return ` ${name}="${safe}"`
         }).join('')
 
-        // 子要素・テキストを組み立て
         let inner = ''
-        // 優先してテキストノードを出す
         if (value['#text'] !== undefined) {
-            inner += this.renderValue(value['#text'])
+            inner += this.renderValue(value['#text'], ctx)
         } else if (value['_text'] !== undefined) {
-            inner += this.renderValue(value['_text'])
+            inner += this.renderValue(value['_text'], ctx)
         }
 
-        // その他の子要素をレンダリング
         childEntries.forEach(([k, v]) => {
             if (k === '#text' || k === '_text') return
-            inner += `<${k}>${this.renderValue(v)}</${k}>`
+            inner += `<${k}>${this.renderValue(v, ctx)}</${k}>`
         })
 
         return `<${tag}${attrs}>${inner}</${tag}>`
     }
 
     /**
-     * XML を解析して pages に HTML を格納
+     * XML を解析して pagesTemplates に生の Content を格納（評価はリクエスト時に行う）
      */
     returnhtml(): string {
         const options = { ignoreAttributes: false }
@@ -141,24 +223,14 @@ export default class Ride {
             const pages = root["Page"]
             if (!pages) return ""
 
-            // Page が配列か単一かを吸収して配列化
             const pageArray = Array.isArray(pages) ? pages : [pages]
 
             pageArray.forEach((page: any) => {
                 const route = page['@_route'] || '/'
-
-                // Content が存在しない場合は空にする
                 const content = page['Content'] || {}
 
-                // 各タグを再帰的にレンダリングして結合
-                const generatedhtml = Object.keys(content).map(tag => {
-                    const value = content[tag]
-                    // 属性付きタグなどを正しく扱う helper を使う
-                    return this.renderContentTag(tag, value)
-                }).join('')
-
-                // ページを格納（タイトルを付与）
-                this.pages[route] = `<title>${this.name}</title>` + generatedhtml
+                // 生の content を保存しておく（ルートアクセス時に評価する）
+                this.pagesTemplates[route] = { content, pageMeta: page }
             })
         } catch (e) {
             console.error("Whoops, an error occurred during analysis : " + e)
@@ -171,19 +243,45 @@ export default class Ride {
      * Ride メソッド（ファイル読み込みと HTML 生成）
      */
     Ride(name: string) {
-        this.F = readFileSync(path.join(__dirname, "../../", name), { encoding: "utf-8"})
+        // this.F = readFileSync(path.join(__dirname, "../../", name), { encoding: "utf-8"})
+        this.F = readFileSync(path.join(process.cwd(), name), { encoding: "utf-8"})
         this.returnhtml()
     }
 
     /**
      * 簡易サーバを起動
+     * - リクエスト毎に { ... } の評価を行い、req, query, params, body, server（defaultContext）, page が参照可能になる
      */
     serve(port: number) {
         const app = exp();
 
-        Object.keys(this.pages).forEach(route => {
+        Object.keys(this.pagesTemplates).forEach(route => {
             app.get(route, (req, res) => {
-                res.send(this.pages[route])
+                const tpl = this.pagesTemplates[route]
+                const content = tpl?.content || {}
+
+                // コンテキストを組み立て（デフォルト + リクエスト情報 + ページメタ）
+                const ctx = {
+                    server: this.defaultContext,
+                    req: {
+                        params: req.params,
+                        query: req.query,
+                        path: req.path,
+                        headers: req.headers
+                    },
+                    page: tpl.pageMeta || {},
+                    // 任意のデータを追加できるように空の data を用意
+                    data: {}
+                }
+
+                // 各タグを評価して結合
+                const generatedhtml = Object.keys(content).map(tag => {
+                    const value = content[tag]
+                    return this.renderContentTag(tag, value, ctx)
+                }).join('')
+
+                // タイトルを付与して送信
+                res.send(`<title>${this.name}</title>` + generatedhtml)
             })
         })
 
@@ -194,7 +292,11 @@ export default class Ride {
         return app
     }
 
+    /**
+     * サーバ側で渡したい既定のコンテキストを設定する
+     * 例: ride.config({ currentUser: {...}, env: process.env.NODE_ENV })
+     */
     config(options: object) {
-        // 将来の拡張ポイント
+        this.defaultContext = Object.assign({}, this.defaultContext, options)
     }
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "node-riner",
-  "version": "1.3.1",
+  "version": "2.0.0",
   "main": "index.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "dev": "tsx script.ts"
+    "dev": "tsx t.ts"
   },
   "keywords": [],
   "author": "",

package/runs.js

@@ -1 +0,0 @@
-// debug