functionalscript 0.12.4 → 0.12.6

package/ci/module.f.js

@@ -69,7 +69,7 @@ const node = (version) => (extra) => basicNode(version)([
 const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';
 const playwrightVersion = '1.58.2';
 const playwrightAndVersion = `playwright@${playwrightVersion}`;
-const rustToolchain = '1.93.1';
+const rustToolchain = '1.94.1';
 const toSteps = (m) => {
     const filter = (st) => m.flatMap((mt) => mt.type === st ? [mt.step] : []);
     const aptGet = m.flatMap(v => v.type === 'apt-get' ? [v.package] : []).join(' ');

package/io/module.f.d.ts

@@ -1,5 +1,5 @@
 import { type Effect } from '../types/effects/module.f.ts';
-import type { Headers, NodeOp } from '../types/effects/node/module.f.ts';
+import type { ExecResult, Headers, IoResult, NodeOp } from '../types/effects/node/module.f.ts';
 import { type Result } from '../types/result/module.f.ts';
 /**
  * Represents a directory entry (file or directory) in the filesystem
@@ -96,6 +96,9 @@ export type RequestListener = (req: IncomingMessage, res: ServerResponse) => Pro
 export type Http = {
     readonly createServer: (_: RequestListener) => Server;
 };
+export type ChildProcess = {
+    readonly exec: (command: string) => Promise<IoResult<ExecResult>>;
+};
 /**
  * Core IO operations interface providing access to system resources
  */
@@ -109,6 +112,7 @@ export type Io = {
     readonly tryCatch: TryCatch;
     readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
     readonly http: Http;
+    readonly childProcess: ChildProcess;
 };
 /**
  * The environment variables.
@@ -124,4 +128,4 @@ export type Run = (f: App) => Promise<never>;
  */
 export declare const run: (io: Io) => Run;
 export type EffectToPromise = <T>(effect: Effect<NodeOp, T>) => Promise<T>;
-export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, http: { createServer }, }: Io) => EffectToPromise;
+export declare const fromIo: ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess: { exec }, }: Io) => EffectToPromise;

package/io/module.f.js

@@ -35,7 +35,7 @@ const collect = async (v) => {
     }
     return result;
 };
-export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile } }, fetch, http: { createServer }, }) => {
+export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readFile, readdir, writeFile, rm } }, fetch, http: { createServer }, childProcess: { exec }, }) => {
     const result = asyncRun({
         all: async (effects) => await Promise.all(effects.map(result)),
         error: async (message) => error(message),
@@ -52,6 +52,8 @@ export const fromIo = ({ console: { error, log }, fs: { promises: { mkdir, readF
         readdir: ([path, r]) => tc(async () => (await readdir(path, { ...r, withFileTypes: true }))
             .map(v => ({ name: v.name, parentPath: normalize(v.parentPath), isFile: v.isFile() }))),
         writeFile: ([path, data]) => tc(() => writeFile(path, fromVec(data))),
+        rm: path => tc(() => rm(path)),
+        exec,
         createServer: async (requestListener) => {
             const erl = requestListener;
             const nodeRl = async (req, res) => {

package/io/module.js

@@ -7,6 +7,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import http from 'node:http';
+import { exec } from 'node:child_process';
 import { fromIo, run } from "./module.f.js";
 import fs from 'node:fs';
 import process from 'node:process';
@@ -41,6 +42,9 @@ export const io = {
         }
     },
     http,
+    childProcess: {
+        exec: command => new Promise(resolve => exec(command, (e, stdout, stderr) => resolve(e !== null ? error(e) : ok({ stdout, stderr })))),
+    },
 };
 export const legacyRun = run(io);
 export const ioRun = (io) => {

package/io/virtual/module.f.js

@@ -36,5 +36,8 @@ export const createVirtualIo = (files) => ({
     asyncTryCatch: async (f) => ['ok', await f()],
     http: {
         createServer: todo
-    }
+    },
+    childProcess: {
+        exec: todo,
+    },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.12.4",
+  "version": "0.12.6",
   "type": "module",
   "files": [
     "**/*.js",

package/types/effects/node/module.f.d.ts

@@ -41,7 +41,15 @@ export declare const readdir: RestFunc<Readdir>;
 export type WriteFileParam = readonly [string, Vec];
 export type WriteFile = readonly ['writeFile', (_: WriteFileParam) => IoResult<void>];
 export declare const writeFile: RestFunc<WriteFile>;
-export type Fs = Mkdir | ReadFile | Readdir | WriteFile;
+export type Rm = readonly ['rm', (_: string) => IoResult<void>];
+export declare const rm: Func<Rm>;
+export type ExecResult = {
+    readonly stdout: string;
+    readonly stderr: string;
+};
+export type Exec = readonly ['exec', (_: string) => IoResult<ExecResult>];
+export declare const exec: Func<Exec>;
+export type Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm | Exec;
 export type Error = ['error', (_: string) => void];
 export declare const error: Func<Error>;
 export type Log = ['log', (_: string) => void];

package/types/effects/node/module.f.js

@@ -14,6 +14,8 @@ export const mkdir = doRest('mkdir');
 export const readFile = do_('readFile');
 export const readdir = doRest('readdir');
 export const writeFile = doRest('writeFile');
+export const rm = do_('rm');
+export const exec = do_('exec');
 export const error = do_('error');
 export const log = do_('log');
 export const createServer = do_('createServer');

package/types/effects/node/test.f.d.ts

@@ -24,5 +24,11 @@ declare const _default: {
         nestedPath: () => void;
         directory: () => void;
     };
+    rm: {
+        one: () => void;
+        nested: () => void;
+        noSuchFile: () => void;
+        isDirectory: () => void;
+    };
 };
 export default _default;

package/types/effects/node/test.f.js

@@ -1,6 +1,6 @@
 import { empty, isVec, uint, vec8 } from "../../bit_vec/module.f.js";
 import { pure } from "../module.f.js";
-import { fetch, mkdir, readdir, readFile, writeFile } from "./module.f.js";
+import { fetch, mkdir, readdir, readFile, rm, writeFile } from "./module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
 export default {
     map: () => {
@@ -272,4 +272,58 @@ export default {
             }
         },
     },
+    rm: {
+        one: () => {
+            const [state, [t, result]] = virtual({
+                ...emptyState,
+                root: { hello: vec8(0x2an) },
+            })(rm('hello'));
+            if (t !== 'ok') {
+                throw result;
+            }
+            if (state.root.hello !== undefined) {
+                throw state.root;
+            }
+        },
+        nested: () => {
+            const [state, [t, result]] = virtual({
+                ...emptyState,
+                root: { tmp: { cache: vec8(0x15n) } },
+            })(rm('tmp/cache'));
+            if (t !== 'ok') {
+                throw result;
+            }
+            const tmp = state.root.tmp;
+            if (tmp === undefined || isVec(tmp)) {
+                throw state.root;
+            }
+            if (tmp.cache !== undefined) {
+                throw tmp;
+            }
+        },
+        noSuchFile: () => {
+            const [_, [t, result]] = virtual(emptyState)(rm('hello'));
+            if (t !== 'error') {
+                throw result;
+            }
+            if (result !== 'no such file') {
+                throw result;
+            }
+        },
+        isDirectory: () => {
+            const [state, [t, result]] = virtual({
+                ...emptyState,
+                root: { tmp: {} },
+            })(rm('tmp'));
+            if (t !== 'error') {
+                throw result;
+            }
+            if (result !== 'invalid path') {
+                throw result;
+            }
+            if (state.root.tmp === undefined) {
+                throw state.root;
+            }
+        },
+    },
 };

package/types/effects/node/virtual/module.f.js

@@ -94,6 +94,21 @@ const readdir = (base, recursive) => readOperation((dir, path) => {
     };
     return ok(f(base, dir));
 });
+const rm = operation((dir, path) => {
+    if (path.length !== 1) {
+        return [dir, error('invalid path')];
+    }
+    const [name] = path;
+    const entry = dir[name];
+    if (entry === undefined) {
+        return [dir, error('no such file')];
+    }
+    if (!isVec(entry)) {
+        return [dir, error('is a directory')];
+    }
+    const { [name]: _, ...rest } = dir;
+    return [rest, okVoid];
+});
 const console = (name) => (state, payload) => [{ ...state, [name]: `${state[name]}${payload}\n` }, undefined];
 const map = {
     all: (state, a) => {
@@ -115,6 +130,8 @@ const map = {
     readFile,
     readdir: (state, [path, { recursive }]) => readdir(path, recursive === true)(state, path),
     writeFile: (state, [path, payload]) => writeFile(payload)(state, path),
+    rm: (state, path) => rm(state, path),
+    exec: todo,
     createServer: todo,
     listen: todo,
     forever: todo,