naidejs 1.0.0 → 1.2.0

package/README.md

@@ -9,7 +9,7 @@ Two modes:
 ## Install
 
 ```bash
-npm install -g naide
+npm install -g naidejs
 ```
 
 ## Usage
@@ -19,6 +19,9 @@ npm install -g naide
 naide app.naide
 naide app.nx
 
+# Watch mode (auto-restart on changes)
+naide -w app.naide
+
 # Output generated JavaScript
 naide --emit app.nx
 
@@ -29,6 +32,286 @@ naide -o app.js app.nx
 naide --mid app.nx
 ```
 
+## High-Level Features
+
+NAIDE includes built-in declarations for common backend patterns. Zero dependencies — the runtime is bundled with the package.
+
+### schema — Data models with validation
+
+```python
+schema User:
+  id     auto
+  name   str required min(2) max(50)
+  email  str required email unique
+  age    int optional min(0) max(150)
+  role   enum("admin", "user") default("user")
+  joined timestamp auto
+```
+
+Types: `str`, `int`, `num`, `bool`, `auto` (UUID), `timestamp`, `enum(...)`
+Modifiers: `required`, `optional`, `min(n)`, `max(n)`, `email`, `url`, `unique`, `auto`, `default(val)`
+
+### db — Persistent file storage
+
+```python
+db "data/"
+```
+
+When declared, all schema stores persist to JSON files automatically (`data/User.json`, `data/Todo.json`, etc.). Without `db`, data is in-memory only.
+
+### crud — Auto-generate REST endpoints
+
+```python
+server app port 3000:
+  crud "/api/users" User
+```
+
+Generates GET (list + by ID), POST, PUT, DELETE routes with validation.
+
+**Built-in pagination, search, and sort:**
+```
+GET /api/users                     # paginated (default 20 per page)
+GET /api/users?page=2&limit=10     # page 2, 10 items
+GET /api/users?q=john              # search all string fields
+GET /api/users?sort=name&order=asc # sort by field
+```
+
+Response format: `{ data: [...], total, page, limit, pages }`
+
+### auth — JWT authentication
+
+```python
+server app port 3000:
+  auth JWT_SECRET:
+    protect "/api/*"
+    public "/api/auth/*"
+```
+
+Built-in JWT sign/verify with no external dependencies.
+
+**Signing tokens in routes:**
+```python
+post "/api/auth/login" (req, res):
+  token = auth.sign({id: user.id})    # uses auth secret automatically
+  ret {token}
+```
+
+Also available as `sign(payload)` (same auto-secret) or `sign(payload, secret)` (explicit).
+
+### Password hashing
+
+```python
+str hashed = hash("mypassword")       # scrypt-based, returns salt:hash
+bool ok = verify("mypassword", hashed) # timing-safe comparison
+```
+
+Zero-dependency — uses Node.js built-in `crypto.scryptSync`.
+
+### cors — CORS middleware
+
+```python
+server app port 3000:
+  cors "*"
+  # or: cors ["localhost:3000", "myapp.com"]
+```
+
+### limit — Rate limiting
+
+```python
+server app port 3000:
+  limit "/api/*" 100 "1m"
+```
+
+### static — Serve static files
+
+```python
+server app port 3000:
+  static "/public"
+```
+
+Serves files from the `public/` directory.
+
+### ws — WebSocket
+
+```python
+server app port 3000:
+  ws "/chat":
+    on "connect":
+      send({type: "welcome"})
+    on "message" (data):
+      broadcast(data)
+    on "close":
+      log "client left"
+```
+
+Built-in `send(data)` and `broadcast(data)` helpers. Requires `npm install ws`.
+
+### group — Route groups
+
+```python
+server app port 3000:
+  group "/api/v1":
+    get "/users":
+      ret users
+    post "/users" (req, res):
+      ret req.body
+```
+
+Generates an Express Router mounted at the prefix. Groups can be nested.
+
+### cookie — Cookie parsing
+
+```python
+server app port 3000:
+  cookie
+  get "/" (req, res):
+    str theme = req.cookies.theme
+    ret {theme}
+```
+
+Parses `Cookie` headers into `req.cookies`. Zero-dependency.
+
+### error — Error handler
+
+```python
+server app port 3000:
+  get "/":
+    ret {ok: true}
+  error (err, req, res):
+    log.error err.message
+    ret.status 500 {error: "Internal error"}
+```
+
+Express error middleware. Catches unhandled errors in routes.
+
+### api — HTTP client
+
+```python
+fn.async getUsers() -> any:
+  any users = await api.get("https://api.example.com/users")
+  ret users
+
+fn.async createUser(map data) -> any:
+  any result = await api.post("https://api.example.com/users", data)
+  ret result
+```
+
+Methods: `api.get(url)`, `api.post(url, body)`, `api.put(url, body)`, `api.del(url)`, `api.raw(url, opts)`.
+Zero-dependency — uses Node.js 18+ built-in `fetch`. Auto-imported when used.
+
+### env — Environment variables with validation
+
+```python
+env:
+  PORT       int default(3000)
+  JWT_SECRET str required
+  DB_URL     str default("sqlite:data.db")
+```
+
+Variables become constants available throughout the file.
+
+### every — Scheduled tasks
+
+```python
+every "5m":
+  log "cleanup running"
+```
+
+Intervals: `"30s"`, `"5m"`, `"1h"`, `"1d"`
+
+### watch — React to events
+
+```python
+watch User.create (event):
+  log "new user: {event.data.name}"
+```
+
+Automatically connected to `crud` events.
+
+### Response helpers
+
+```python
+ret {data: items}              # JSON response (default)
+ret.status 404 {error: "nope"} # custom status code
+ret.redirect "/login"           # HTTP redirect
+ret.html "<h1>Hello</h1>"      # HTML response
+ret.text "pong"                 # plain text response
+ret.file "/path/to/file"       # send file
+```
+
+### Built-in functions
+
+```python
+str id = uuid()                         # generate UUID
+str hashed = hash("password")           # hash password
+bool ok = verify("password", hashed)    # verify password
+str token = sign({id: 1})               # sign JWT (uses auth secret)
+str token = sign({id: 1}, "my-secret")  # sign JWT (explicit secret)
+```
+
+These are auto-imported from the runtime when used.
+
+### Full example
+
+```python
+db "data/"
+
+env:
+  PORT int default(3000)
+  JWT_SECRET str required
+
+schema User:
+  id auto
+  name str required min(2) max(50)
+  email str required email
+  password str required
+
+server app port PORT:
+  cors "*"
+  cookie
+  auth JWT_SECRET:
+    protect "/api/*"
+    public "/api/auth/*"
+  limit "/api/*" 100 "1m"
+  static "/public"
+  crud "/api/users" User
+
+  group "/api/v1":
+    get "/status":
+      ret {version: "1.0"}
+
+  post "/api/auth/register" (req, res):
+    str hashed = hash(req.body.password)
+    user = UserStore.create({...req.body, password: hashed})
+    token = auth.sign({id: user.id})
+    ret {token, user}
+
+  post "/api/auth/login" (req, res):
+    user = UserStore.where({email: req.body.email})[0]
+    if not user:
+      ret.status 401 {error: "Invalid credentials"}
+    if not verify(req.body.password, user.password):
+      ret.status 401 {error: "Invalid credentials"}
+    token = auth.sign({id: user.id})
+    ret {token}
+
+  ws "/chat":
+    on "message" (data):
+      broadcast(data)
+
+  get "/":
+    ret.html "<h1>Welcome</h1>"
+
+  error (err, req, res):
+    log.error err.message
+    ret.status 500 {error: "Something went wrong"}
+
+watch User.create (event):
+  log "new user: {event.data.name}"
+```
+
+This generates a complete production API with persistent storage, auth, password hashing, CORS, cookies, rate limiting, CRUD with pagination/search, WebSocket, route groups, error handling, and static files — from ~45 lines.
+
 ## NAIDE syntax (.naide)
 
 ```python
@@ -37,7 +320,7 @@ str name = "World"
 int count = 3
 mut int counter = 0
 
-# Functions — one way only
+# Functions
 fn greet(str who) -> str:
   ret "Hello, {who}!"
 
@@ -118,12 +401,21 @@ f greet(s:who)s
 @i<0..10
   log i
 
--- Server
+-- Server with high-level features
 $app:3000
+  cors "*"
+  auth SECRET:
+    protect "/api/*"
+  static "/public"
+  crud "/api/users" User
   G"/users"
     >users
   P"/users"(req,res)
     >req.body
+  G"/old"
+    >.r "/new"
+  G"/"
+    >.h "<h1>Hello</h1>"
 
 -- Error handling
 !
@@ -153,9 +445,13 @@ $app:3000
 | `+` | export | `~` | await |
 | `G` | GET | `P` | POST |
 | `U` | PUT | `D` | DELETE |
+| `>.s` | ret.status | `>.r` | ret.redirect |
+| `>.h` | ret.html | `>.t` | ret.text |
 
 Types: `s`=str `i`=int `n`=num `b`=bool `l`=list `m`=map `a`=any
 
+High-level: `schema`, `crud`, `auth`, `cors`, `limit`, `env`, `every`, `watch`, `static`, `ws`, `db`, `group`, `cookie`, `error` — same syntax in both modes. `api` is auto-imported.
+
 ## Why?
 
 AI code generation speed depends on:

package/SPEC-X.nx

@@ -112,13 +112,86 @@ l:result=[1,2,3,4,5]
   f perms()l
     >["read","write","delete"]
 
--- Server: $name:port
--- Routes: G P U D + "path"
--- $app:3000
---   G"/users"
---     >users
---   P"/users"(req,res)
---     >req.body
+-- DB persistence: db "path/"
+db "data/"
+
+-- Environment variables
+env:
+  PORT int default(3000)
+  JWT_SECRET str required
+
+-- Schema: types + modifiers
+schema User:
+  id auto
+  name str required min(2) max(50)
+  email str required email unique
+  role enum("admin","user") default("user")
+  joined timestamp auto
+
+-- Server with high-level features
+$app:PORT
+  cors "*"
+  auth JWT_SECRET:
+    protect "/api/*"
+    public "/api/auth/*"
+  limit "/api/*" 100 "1m"
+  static "/public"
+  crud "/api/users" User
+  cookie
+  group "/api/v1":
+    G"/status"
+      >{version:"1.0"}
+  G"/"
+    >.h "<h1>Welcome</h1>"
+  P"/api/auth/register"(req,res)
+    s:hashed=hash(req.body.password)
+    user=UserStore.create({...req.body,password:hashed})
+    token=auth.sign({id:user.id})
+    >{token,user}
+  P"/api/auth/login"(req,res)
+    user=UserStore.where({email:req.body.email})[0]
+    ?not user
+      >.s 401 {error:"Invalid credentials"}
+    ?not verify(req.body.password,user.password)
+      >.s 401 {error:"Invalid credentials"}
+    token=sign({id:user.id})
+    >{token}
+  ws "/chat":
+    on "connect":
+      send({type:"welcome"})
+    on "message" (data):
+      broadcast(data)
+
+-- Error handler
+  error (err, req, res):
+    log.e err.message
+    >.s 500 {error:"Internal error"}
+
+-- HTTP client (auto-imported)
+-- api.get(url) api.post(url,body) api.put(url,body) api.del(url) api.raw(url,opts)
+
+-- Return helpers
+-- >expr         → JSON
+-- >.s CODE expr → status code
+-- >.r "/path"   → redirect
+-- >.h "<html>"  → HTML
+-- >.t "text"    → plain text
+-- >.f "/file"   → send file
+
+-- Built-in functions (auto-imported)
+-- uuid()                → UUID
+-- hash("password")      → scrypt hash
+-- verify("pw",hashed)   → verify
+-- sign({id:1})          → JWT (uses auth secret)
+-- sign({id:1},"secret") → JWT (explicit)
+
+-- Scheduled tasks
+every "5m":
+  log"cleanup"
+
+-- Event watch
+watch User.create (event):
+  log"new: {event.data.name}"
 
 -- Import: <module or <{names}"module"
 -- <express

package/SPEC.naide

@@ -137,11 +137,124 @@ model Admin extends User:
     ret ["read", "write", "delete"]
 
 
+# ---- データベース永続化 ----
+# db ディレクトリパス → スキーマストアがJSONファイルに自動保存
+db "data/"
+
+
+# ---- 環境変数 ----
+env:
+  PORT       int default(3000)
+  JWT_SECRET str required
+  DB_URL     str default("sqlite:data.db")
+
+
+# ---- スキーマ定義 ----
+# 型: str, int, num, bool, auto(UUID), timestamp, enum(...)
+# 修飾: required, optional, min(n), max(n), email, url, unique, auto, default(val)
+schema User:
+  id       auto
+  name     str required min(2) max(50)
+  email    str required email unique
+  age      int optional min(0) max(150)
+  role     enum("admin", "user") default("user")
+  joined   timestamp auto
+
+
 # ---- サーバー定義 ----
-# Express.jsのボイラープレートが不要
-# server 名前 port ポート:
-#   get "/path" (req, res):
-#     ret {data: "response"}
+server app port PORT:
+  # CORS
+  cors "*"
+
+  # JWT認証
+  auth JWT_SECRET:
+    protect "/api/*"
+    public "/api/auth/*"
+
+  # レート制限
+  limit "/api/*" 100 "1m"
+
+  # 静的ファイル配信
+  static "/public"
+
+  # CRUD自動生成 (ページネーション・検索・ソート付き)
+  crud "/api/users" User
+
+  # クッキーパーサー
+  cookie
+
+  # ルートグループ
+  group "/api/v1":
+    get "/status":
+      ret {version: "1.0"}
+
+  # ルート
+  get "/":
+    ret.html "<h1>Welcome</h1>"
+
+  post "/api/auth/register" (req, res):
+    str hashed = hash(req.body.password)
+    user = UserStore.create({...req.body, password: hashed})
+    token = auth.sign({id: user.id})
+    ret {token, user}
+
+  post "/api/auth/login" (req, res):
+    user = UserStore.where({email: req.body.email})[0]
+    if not user:
+      ret.status 401 {error: "Invalid credentials"}
+    if not verify(req.body.password, user.password):
+      ret.status 401 {error: "Invalid credentials"}
+    token = sign({id: user.id})
+    ret {token}
+
+  # WebSocket
+  ws "/chat":
+    on "connect":
+      send({type: "welcome"})
+    on "message" (data):
+      broadcast(data)
+    on "close":
+      log "client left"
+
+  # エラーハンドラー
+  error (err, req, res):
+    log.error err.message
+    ret.status 500 {error: "Internal error"}
+
+
+# ---- HTTPクライアント (自動インポート) ----
+# any data = await api.get("https://api.example.com/users")
+# any result = await api.post("https://api.example.com/users", {name: "test"})
+# any result = await api.put(url, body)
+# any result = await api.del(url)
+# any raw = await api.raw(url, opts)
+
+
+# ---- レスポンスヘルパー ----
+# ret {data}                → JSON応答
+# ret.status 404 {error}    → ステータスコード付き
+# ret.redirect "/login"     → リダイレクト
+# ret.html "<h1>Hi</h1>"   → HTML応答
+# ret.text "pong"           → テキスト応答
+# ret.file "/path/to/file" → ファイル送信
+
+
+# ---- 組み込み関数 (自動インポート) ----
+# str id = uuid()                    → UUID生成
+# str h = hash("password")           → パスワードハッシュ (scrypt)
+# bool ok = verify("password", h)    → パスワード検証
+# str token = sign({id: 1})          → JWT署名 (auth秘密鍵を自動使用)
+# str token = sign({id: 1}, "secret") → JWT署名 (明示的秘密鍵)
+
+
+# ---- スケジュールタスク ----
+every "5m":
+  log "cleanup running"
+
+
+# ---- イベント監視 ----
+watch User.create (event):
+  log "new user: {event.data.name}"
 
 
 # ---- インポート ----
@@ -151,11 +264,6 @@ model Admin extends User:
 # use モジュール as 別名
 
 
-# ---- イベント ----
-# on オブジェクト.イベント:
-#   ハンドラ
-
-
 # ---- ログ ----
 log "info message"
 log.error "error message"

package/bin/naide.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
-import { readFileSync, writeFileSync } from 'fs';
+import { readFileSync, writeFileSync, unlinkSync, watch as fsWatch } from 'fs';
 import { resolve, basename, extname } from 'path';
 import { compile } from '../src/index.js';
+import { spawn } from 'child_process';
 
 const args = process.argv.slice(2);
 
@@ -15,6 +16,7 @@ const flags = {
   help: false,
   mode: null,
   mid: false,
+  watch: false,
 };
 
 const files = [];
@@ -29,6 +31,7 @@ for (let i = 0; i < args.length; i++) {
     case '--help': case '-h': flags.help = true; break;
     case '--x': case '-x': flags.mode = 'x'; break;
     case '--mid': flags.mid = true; flags.run = false; break;
+    case '--watch': case '-w': flags.watch = true; break;
     default: files.push(arg);
   }
 }
@@ -44,6 +47,7 @@ if (flags.help || files.length === 0) {
     naide --emit <file.nx>       Output generated JavaScript
     naide --mid <file.nx>        Output intermediate NAIDE v1 (debug)
     naide -x <file.naide>        Force NAIDE-X mode
+    naide -w <file.naide>        Watch mode (auto-restart on changes)
 
   Modes:
     .naide  Standard NAIDE (~40% fewer tokens than JS)
@@ -53,6 +57,7 @@ if (flags.help || files.length === 0) {
     -e, --emit     Print generated JavaScript
     -o, --output   Write generated JavaScript to file
     -x             Force NAIDE-X mode
+    -w, --watch    Watch mode: restart on file changes
     --mid          Show intermediate NAIDE v1 (X mode only)
     --ast          Print AST
     --tokens       Print tokens
@@ -61,6 +66,8 @@ if (flags.help || files.length === 0) {
   process.exit(0);
 }
 
+const runtimeUrl = new URL('../src/runtime.js', import.meta.url).href;
+
 for (const file of files) {
   const filePath = resolve(file);
   let source;
@@ -81,7 +88,57 @@ for (const file of files) {
       continue;
     }
 
-    const result = compile(source, { mode });
+    const runtimePath = flags.emit || flags.output ? 'naidejs/runtime' : runtimeUrl;
+
+    if (flags.watch) {
+      const tempFile = resolve(`.naide_tmp_${basename(file, ext)}.mjs`);
+      let child = null;
+
+      function start() {
+        try {
+          source = readFileSync(filePath, 'utf-8');
+          const result = compile(source, { mode, runtimePath });
+          writeFileSync(tempFile, result.js, 'utf-8');
+          child = spawn(process.execPath, [tempFile], { stdio: 'inherit' });
+          child.on('error', (err) => console.error(`[NAIDE] Process error: ${err.message}`));
+          child.on('exit', (code) => {
+            if (code !== null && code !== 0) console.log(`[NAIDE] Process exited with code ${code}`);
+          });
+        } catch (err) {
+          console.error(`\n${err.message}`);
+        }
+      }
+
+      function restart() {
+        console.log('\n[NAIDE] Change detected. Restarting...');
+        if (child) { child.kill(); child = null; }
+        start();
+      }
+
+      console.log(`[NAIDE] Watch mode — ${file}`);
+      start();
+
+      let debounce = null;
+      fsWatch(filePath, () => {
+        if (debounce) clearTimeout(debounce);
+        debounce = setTimeout(restart, 200);
+      });
+
+      process.on('SIGINT', () => {
+        if (child) child.kill();
+        try { unlinkSync(tempFile); } catch {}
+        process.exit(0);
+      });
+
+      process.on('SIGTERM', () => {
+        if (child) child.kill();
+        process.exit(0);
+      });
+
+      continue;
+    }
+
+    const result = compile(source, { mode, runtimePath });
 
     if (flags.tokens) {
       console.log(JSON.stringify(result.tokens, null, 2));