@gera2ld/common-node 0.0.1

package/dist/cgi.d.ts

@@ -0,0 +1,13 @@
+export interface ICGIConfig {
+    cgiDir: string;
+    runnerMap: Record<string, string[]>;
+    env: Record<string, string>;
+    timeout: number;
+    disallowedPattern: {
+        test: (str: string) => boolean;
+    };
+}
+export declare const defaultConfig: ICGIConfig;
+export declare function createCGIHandler(overrideConfig: Partial<ICGIConfig>, options?: {
+    log?: (str: string) => void;
+}): (request: Request) => Promise<Response>;

package/dist/cli.d.ts

@@ -0,0 +1,23 @@
+import { type SpawnOptions } from 'node:child_process';
+export interface ICommandOutput {
+    success: boolean;
+    code: number | null;
+    signal: string | null;
+    stdout: () => Promise<Uint8Array>;
+    stderr: () => Promise<Uint8Array>;
+}
+export declare class CommandError extends Error {
+    output: ICommandOutput;
+    constructor(output: ICommandOutput);
+}
+type StdioValue = 'inherit' | 'ignore' | 'pipe';
+type StdioTuple = [StdioValue, StdioValue, StdioValue];
+export declare function runCommand(args: string[], commandOptions?: SpawnOptions & {
+    stdio?: StdioTuple;
+}, extraOptions?: {
+    ensureSuccess?: boolean;
+    stdin?: Uint8Array | ArrayBuffer | string;
+    buffer?: 'stdout' | 'stderr' | boolean;
+}): Promise<ICommandOutput>;
+export declare function readStdIn(): Promise<NonSharedBuffer | undefined>;
+export {};

package/dist/env.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureEnv(key: string): string;
+export declare function ensureEnvs(keys: string[]): Record<string, string>;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cgi';
+export * from './cli';
+export * from './env';
+export * from './kv';
+export * from './sqlite-common';

package/dist/index.js

@@ -0,0 +1,415 @@
+import { spawn as D } from "node:child_process";
+import { stat as A, mkdir as v, readFile as q, writeFile as U, readdir as S, rm as P, access as L, rename as $ } from "node:fs/promises";
+import { resolve as C, extname as z, dirname as g, normalize as K, join as d } from "node:path";
+import R from "node:process";
+import { Readable as E } from "node:stream";
+import { buffer as k } from "node:stream/consumers";
+import { isatty as O } from "node:tty";
+function W(r) {
+  return new TextEncoder().encode(r);
+}
+function b() {
+  const r = {
+    status: "pending"
+  };
+  return r.promise = new Promise((t, e) => {
+    r.resolve = t, r.reject = e;
+  }), r.promise.then(
+    () => {
+      r.status = "resolved";
+    },
+    () => {
+      r.status = "rejected";
+    }
+  ), r;
+}
+const x = new Uint8Array([13, 10]);
+class J {
+  buffer = new Uint8Array(0);
+  requests = [];
+  isClosed = !1;
+  read(t = 8192) {
+    const e = b();
+    return this.requests.push({
+      deferred: e,
+      handle: () => {
+        const s = Math.min(t, this.buffer.length), a = this.buffer.subarray(0, s);
+        return this.buffer = this.buffer.subarray(s), e.resolve(a), !0;
+      }
+    }), this.processBuffer(), e.promise;
+  }
+  readExact(t) {
+    const e = b();
+    return this.requests.push({
+      deferred: e,
+      handle: () => {
+        if (t > this.buffer.length) return !1;
+        const s = this.buffer.subarray(0, t);
+        return this.buffer = this.buffer.subarray(t), e.resolve(s), !0;
+      }
+    }), this.processBuffer(), e.promise;
+  }
+  readUntil(t = x) {
+    typeof t == "string" && (t = W(t));
+    const e = b();
+    return this.requests.push({
+      deferred: e,
+      handle: () => {
+        const s = G(this.buffer, t);
+        if (s < 0) return !1;
+        const a = s + t.length, n = this.buffer.subarray(0, a);
+        return this.buffer = this.buffer.subarray(a), e.resolve(n), !0;
+      }
+    }), this.processBuffer(), e.promise;
+  }
+  feed(t) {
+    if (this.isClosed) throw new Error("Buffer is closed");
+    this.buffer = V(this.buffer, t), this.processBuffer();
+  }
+  close() {
+    this.isClosed = !0, this.processBuffer();
+  }
+  processBuffer() {
+    for (; this.requests.length; ) {
+      const t = this.requests[0];
+      if (!t.handle())
+        if (this.isClosed)
+          t.deferred.reject(new Error("Buffer is closed"));
+        else break;
+      this.requests.shift();
+    }
+  }
+}
+function V(r, t) {
+  const e = new Uint8Array(r.length + t.length);
+  return e.set(r, 0), e.set(t, r.length), e;
+}
+function G(r, t) {
+  if (!t.length) return 0;
+  for (let e = 0; e <= r.length - t.length; e += 1) {
+    let s;
+    for (s = 0; s < t.length && r[e + s] === t[s]; s += 1)
+      ;
+    if (s === t.length) return e;
+  }
+  return -1;
+}
+const Q = {
+  cgiDir: R.env.CGI_DIR || "cgi",
+  runnerMap: {
+    ".js": ["node"],
+    ".sh": ["bash"]
+  },
+  env: {},
+  timeout: 1e4,
+  // Do not allow directories or files starting with `.` or `_`
+  disallowedPattern: /\/[._]/
+};
+function it(r, t) {
+  return async function(s) {
+    const a = new URL(s.url), n = "." + C(a.pathname), i = {
+      ...Q,
+      ...r
+    };
+    if (i.disallowedPattern.test(n))
+      return new Response(null, { status: 403 });
+    const o = C(i.cgiDir, n);
+    try {
+      await A(o);
+    } catch {
+      return new Response(null, { status: 404 });
+    }
+    const u = i.runnerMap[z(o)];
+    try {
+      if (!u) throw new Error("Unsupported command");
+      t?.log?.(`Run hook: ${n}`);
+      const [f, ...w] = [...u, o], c = D(f, w, {
+        cwd: g(o),
+        env: {
+          ...R.env,
+          ...i.env,
+          HTTP_METHOD: s.method,
+          HTTP_URL: s.url,
+          HTTP_HEADERS: [...s.headers.entries()].map((l) => `${l[0]}: ${l[1]}`).join(`
+`)
+        },
+        stdio: ["pipe", "pipe", "inherit"],
+        timeout: i.timeout
+      });
+      s.body ? E.fromWeb(s.body).pipe(c.stdin) : c.stdin.end();
+      let y = !1;
+      const h = new J(), N = h.readUntil(`
+
+`).finally(() => {
+        y = !0;
+      });
+      for await (const l of c.stdout)
+        if (h.feed(l), y) break;
+      y || h.close();
+      const B = await N, M = JSON.parse(new TextDecoder().decode(B)), { status: m, ...j } = M;
+      let p = m ? +m : 200;
+      if (isNaN(p) || p < 100 || p > 999)
+        throw new Error(`Invalid status code: ${m}`);
+      c.exitCode && (console.error("Script exit code:", c.exitCode), p = 500);
+      const F = E.toWeb(
+        E.from(
+          (async function* () {
+            for (; ; ) {
+              const l = await h.read();
+              if (!l.length) break;
+              yield l;
+            }
+            for await (const l of c.stdout)
+              yield l;
+          })()
+        )
+      );
+      return new Response(F, {
+        status: p,
+        headers: j
+      });
+    } catch (f) {
+      return t?.log?.(`Error: ${f}`), new Response("Internal server error", {
+        status: 500
+      });
+    }
+  };
+}
+class X extends Error {
+  constructor(t) {
+    super(`Command exit code: ${t.code}`), this.output = t;
+  }
+}
+async function ot(r, t, e) {
+  const s = e?.ensureSuccess ?? !0, a = [
+    ...t?.stdio || ["ignore", "inherit", "inherit"]
+  ];
+  e?.stdin && (a[0] = "pipe"), e?.buffer && (e.buffer !== "stderr" && (a[1] = "pipe"), e.buffer !== "stdout" && (a[2] = "pipe"));
+  const n = D(r[0], r.slice(1), {
+    ...t,
+    stdio: a
+  });
+  if (e?.stdin && n.stdin) {
+    const c = typeof e.stdin == "string" ? new TextEncoder().encode(e.stdin) : e.stdin instanceof ArrayBuffer ? new Uint8Array(e.stdin) : e.stdin;
+    n.stdin.write(c), n.stdin.end();
+  }
+  const i = n.stdout && k(n.stdout), o = n.stderr && k(n.stderr), u = await new Promise(
+    (c) => n.on("exit", (y, h) => {
+      c({ code: y, signal: h });
+    })
+  ), f = !u.code && !u.signal, w = {
+    success: f,
+    code: u.code,
+    signal: u.signal,
+    async stdout() {
+      if (!i) throw new Error("stdout is not available");
+      return i;
+    },
+    async stderr() {
+      if (!o) throw new Error("stderr is not available");
+      return o;
+    }
+  };
+  if (s && !f)
+    throw new X(w);
+  return w;
+}
+async function ct() {
+  return O(process.stdin.fd) ? void 0 : await k(process.stdin);
+}
+function _(r) {
+  const t = R.env[r];
+  if (!t)
+    throw new Error(`Missing environment variable: ${r}`);
+  return t;
+}
+function ut(r) {
+  const t = {}, e = [];
+  for (const s of r)
+    try {
+      const a = _(s);
+      t[s] = a;
+    } catch {
+      e.push(s);
+    }
+  if (e.length)
+    throw new Error(`Missing environment variables: ${e.join(", ")}`);
+  return t;
+}
+class T {
+  constructor(t, e) {
+    this.root = t, this.options = { ...T.defaultOptions, ...e };
+  }
+  static defaultOptions = {
+    pathToKey: (t) => t.endsWith(".txt") ? t.slice(0, -4) : void 0,
+    keyToPath: (t) => t + ".txt"
+  };
+  static async open(t = ".", e) {
+    return await v(t, { recursive: !0 }), new T(t, e);
+  }
+  options;
+  normalizeKey(t) {
+    const e = K("./" + this.options.keyToPath(t)).replaceAll(
+      "\\",
+      "/"
+    );
+    if (e.startsWith(".")) throw new Error("Invalid key");
+    return e;
+  }
+  async get(t) {
+    const e = d(this.root, this.normalizeKey(t));
+    try {
+      return await q(e, "utf8");
+    } catch {
+    }
+  }
+  async set(t, e) {
+    const s = d(this.root, this.normalizeKey(t));
+    await v(g(s), { recursive: !0 }), await U(s, e);
+  }
+  async *loadDir(t) {
+    const e = d(this.root, t);
+    for (const s of await S(e)) {
+      const a = d(e, s), n = await A(a), i = d(t, s);
+      if (n.isDirectory())
+        yield* this.loadDir(i);
+      else {
+        const o = this.options.pathToKey(i);
+        o && (yield o);
+      }
+    }
+  }
+  async keys() {
+    const t = [];
+    for await (const e of this.loadDir(""))
+      t.push(e);
+    return t;
+  }
+  async removeEmptyDirs(t) {
+    const e = [this.root, ...t.split("/")];
+    for (e.pop(); e.length > 1; ) {
+      const s = d(...e);
+      if ((await S(s)).length) break;
+      await P(s);
+    }
+  }
+  async del(t) {
+    const e = this.normalizeKey(t), s = d(this.root, e);
+    await P(s), await this.removeEmptyDirs(e);
+  }
+  async rename(t, e) {
+    const s = this.normalizeKey(t), a = this.normalizeKey(e), n = d(this.root, s), i = d(this.root, a);
+    await L(n), await v(g(i), { recursive: !0 }), await $(n, i);
+  }
+  async all() {
+    const t = [];
+    for await (const e of this.loadDir(""))
+      t.push({
+        key: e,
+        value: await this.get(e) || ""
+      });
+    return t;
+  }
+}
+class I {
+  constructor(t, e = {}) {
+    this.path = t, this.data = e;
+  }
+  static async open(t = "kv.json") {
+    const e = new I(t);
+    return await e.load(), e;
+  }
+  async load() {
+    let t;
+    try {
+      t = JSON.parse(await q(this.path, "utf8"));
+    } catch {
+    }
+    t ||= {}, this.data = t;
+  }
+  async dump() {
+    await U(this.path, JSON.stringify(this.data));
+  }
+  async get(t) {
+    return this.data[t];
+  }
+  async set(t, e) {
+    this.data[t] = e, await this.dump();
+  }
+  async keys() {
+    return Object.keys(this.data);
+  }
+  async del(t) {
+    delete this.data[t], await this.dump();
+  }
+  async rename(t, e) {
+    this.data[e] = this.data[t], delete this.data[t], await this.dump();
+  }
+  async all() {
+    return Object.entries(this.data).map(([t, e]) => ({ key: t, value: e }));
+  }
+}
+const Y = `
+CREATE TABLE IF NOT EXISTS kv (
+  key VARCHAR UNIQUE,
+  value VARCHAR
+);
+`;
+class H {
+  constructor(t) {
+    this.adapter = t, t.exec(Y);
+  }
+  static async open(t) {
+    return new H(t);
+  }
+  async get(t) {
+    return this.adapter.queryRow(
+      "SELECT value FROM kv WHERE key=?1",
+      t
+    )?.value;
+  }
+  async set(t, e) {
+    this.adapter.queryRow(
+      "INSERT INTO kv(key, value) VALUES(?1, ?2) ON CONFLICT(key) DO UPDATE SET value=?2",
+      t,
+      e
+    );
+  }
+  async keys() {
+    return this.adapter.queryRows("SELECT key FROM kv").map((e) => e.key);
+  }
+  async del(t) {
+    this.adapter.queryRow("DELETE FROM kv WHERE key=?", t);
+  }
+  async rename(t, e) {
+    this.adapter.queryRow("UPDATE kv SET key=?1 WHERE key=?2", e, t);
+  }
+  async all() {
+    return this.adapter.queryRows(
+      "SELECT key, value FROM kv"
+    );
+  }
+}
+function lt(r) {
+  return function(e) {
+    const { sql: s, params: a, type: n } = {
+      sql: e.sql,
+      params: e.params ?? [],
+      type: e.type ?? "values"
+    }, i = r(), u = i.prepare(s)[n === "values" ? "values" : "all"](...a);
+    return i.destroy(), u;
+  };
+}
+export {
+  X as CommandError,
+  T as KvFile,
+  I as KvJson,
+  H as KvSqlite,
+  it as createCGIHandler,
+  Q as defaultConfig,
+  _ as ensureEnv,
+  ut as ensureEnvs,
+  lt as getSqlHandler,
+  ct as readStdIn,
+  ot as runCommand
+};

package/dist/kv/file.d.ts

@@ -0,0 +1,24 @@
+import type { IKvStorage } from './types.ts';
+export interface IKvFileOptions {
+    pathToKey: (relPath: string) => string | undefined;
+    keyToPath: (key: string) => string;
+}
+export declare class KvFile implements IKvStorage {
+    private root;
+    static defaultOptions: IKvFileOptions;
+    static open(root?: string, options?: Partial<IKvFileOptions>): Promise<KvFile>;
+    options: IKvFileOptions;
+    constructor(root: string, options?: Partial<IKvFileOptions>);
+    private normalizeKey;
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string): Promise<void>;
+    private loadDir;
+    keys(): Promise<string[]>;
+    private removeEmptyDirs;
+    del(key: string): Promise<void>;
+    rename(keyFrom: string, keyTo: string): Promise<void>;
+    all(): Promise<{
+        key: string;
+        value: string;
+    }[]>;
+}

package/dist/kv/index.d.ts

@@ -0,0 +1,4 @@
+export * from './file';
+export * from './json';
+export * from './sqlite';
+export * from './types';

package/dist/kv/json.d.ts

@@ -0,0 +1,18 @@
+import type { IKvStorage } from './types.ts';
+export declare class KvJson implements IKvStorage {
+    private path;
+    private data;
+    static open(path?: string): Promise<KvJson>;
+    constructor(path: string, data?: Record<string, string>);
+    load(): Promise<void>;
+    dump(): Promise<void>;
+    get(key: string): Promise<string>;
+    set(key: string, value: string): Promise<void>;
+    keys(): Promise<string[]>;
+    del(key: string): Promise<void>;
+    rename(keyFrom: string, keyTo: string): Promise<void>;
+    all(): Promise<{
+        key: string;
+        value: string;
+    }[]>;
+}

package/dist/kv/sqlite.d.ts

@@ -0,0 +1,16 @@
+import type { ISqliteAdapter } from '../sqlite-common';
+import type { IKvStorage } from './types';
+export declare class KvSqlite implements IKvStorage {
+    private adapter;
+    static open(adapter: ISqliteAdapter): Promise<KvSqlite>;
+    constructor(adapter: ISqliteAdapter);
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string): Promise<void>;
+    keys(): Promise<string[]>;
+    del(key: string): Promise<void>;
+    rename(key: string, to: string): Promise<void>;
+    all(): Promise<{
+        key: string;
+        value: string;
+    }[]>;
+}

package/dist/kv/types.d.ts

@@ -0,0 +1,11 @@
+export interface IKvStorage {
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string): Promise<void>;
+    keys(): Promise<string[]>;
+    del(key: string): Promise<void>;
+    rename(keyFrom: string, keyTo: string): Promise<void>;
+    all(): Promise<Array<{
+        key: string;
+        value: string;
+    }>>;
+}

package/dist/node/index.d.ts

@@ -0,0 +1 @@
+export * from './sqlite/adapter.ts';

package/dist/node/index.js

@@ -0,0 +1,47 @@
+import { DatabaseSync as s } from "node:sqlite";
+class a {
+  constructor(e) {
+    this.statement = e;
+  }
+  get(...e) {
+    return this.statement.get(...e) || void 0;
+  }
+  all(...e) {
+    return this.statement.all(...e);
+  }
+  values(...e) {
+    return this.all(...e).map((t) => Object.values(t));
+  }
+}
+class i {
+  db;
+  constructor(e, t) {
+    this.db = new s(e, t);
+  }
+  exec(e) {
+    if (!this.db) throw new Error("Database is closed");
+    this.db.exec(e);
+  }
+  transaction(e) {
+    throw new Error("Not supported in Node.js");
+  }
+  prepare(e) {
+    if (!this.db) throw new Error("Database is closed");
+    return new a(this.db.prepare(e));
+  }
+  queryRow(e, ...t) {
+    return this.prepare(e).get(...t);
+  }
+  queryRows(e, ...t) {
+    return this.prepare(e).all(...t);
+  }
+  queryValues(e, ...t) {
+    return this.prepare(e).values(...t);
+  }
+  destroy() {
+    this.db?.close();
+  }
+}
+export {
+  i as SqliteAdapter
+};

package/dist/node/sqlite/adapter.d.ts

@@ -0,0 +1,23 @@
+import { StatementSync } from 'node:sqlite';
+import type { ISqliteAdapter, ISqliteStatement } from '../../sqlite-common/types';
+declare class SqliteStatement<T extends object> implements ISqliteStatement<T> {
+    private statement;
+    constructor(statement: StatementSync);
+    get(...params: any[]): T | undefined;
+    all(...params: any[]): T[];
+    values(...params: any[]): any[][];
+}
+export declare class SqliteAdapter implements ISqliteAdapter {
+    private db;
+    constructor(path: string, options?: {
+        readOnly?: boolean;
+    });
+    exec(sql: string): void;
+    transaction(_cb: () => void): void;
+    prepare<T extends object>(sql: string): SqliteStatement<T>;
+    queryRow<T extends object>(sql: string, ...params: any[]): T | undefined;
+    queryRows<T extends object>(sql: string, ...params: any[]): T[];
+    queryValues(sql: string, ...params: any[]): any[][];
+    destroy(): void;
+}
+export {};

package/dist/sqlite-common/handler.d.ts

@@ -0,0 +1,7 @@
+import type { ISqliteAdapter } from './types';
+export interface ISqlQueryOptions {
+    sql: string;
+    params?: any[] | null;
+    type?: 'values' | 'object' | null;
+}
+export declare function getSqlHandler(factory: () => ISqliteAdapter): (options: ISqlQueryOptions) => object[];

package/dist/sqlite-common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './handler.ts';
+export * from './types.ts';

package/dist/sqlite-common/types.d.ts

@@ -0,0 +1,15 @@
+export type IPrimaryData = string | number | bigint | boolean | Uint8Array;
+export interface ISqliteStatement<T> {
+    get(...params: any[]): T | undefined;
+    all(...params: any[]): T[];
+    values(...params: any[]): IPrimaryData[][];
+}
+export interface ISqliteAdapter {
+    exec(sql: string): void;
+    transaction(cb: () => void): void;
+    prepare<T extends object>(sql: string): ISqliteStatement<T>;
+    queryRow<T extends object>(sql: string, ...params: any[]): T | undefined;
+    queryRows<T extends object>(sql: string, ...params: any[]): T[];
+    queryValues(sql: string, ...params: any[]): IPrimaryData[][];
+    destroy(): void;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@gera2ld/common-node",
+  "version": "0.0.1",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./node": {
+      "import": "./dist/node/index.js",
+      "types": "./dist/node/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@gera2ld/common": "^0.0.1"
+  },
+  "scripts": {
+    "clean": "del-cli dist tsconfig.tsbuildinfo",
+    "build:types": "tsc",
+    "build:js": "vite build",
+    "build": "pnpm clean && pnpm /^build:/"
+  }
+}