From 1d66a0f58e4ebcdf4f42c9d78f82a1ab49a2cf11 Mon Sep 17 00:00:00 2001 From: Elizabeth Hunt Date: Tue, 13 May 2025 18:58:45 -0700 Subject: snapshot! --- u/deno.json | 6 +++ u/fn/callable.ts | 15 +++++++ u/fn/either.ts | 62 +++++++++++++++++++++++++++++ u/fn/mod.ts | 2 + u/leftpadesque/debug.ts | 11 +++++ u/leftpadesque/mod.ts | 3 ++ u/leftpadesque/object.ts | 2 + u/leftpadesque/prepend.ts | 4 ++ u/mod.ts | 4 ++ u/process/env.ts | 10 +++++ u/process/mod.ts | 3 ++ u/process/run.ts | 40 +++++++++++++++++++ u/process/validate_identifier.ts | 17 ++++++++ u/server/mod.ts | 0 u/trace/itrace.ts | 72 +++++++++++++++++++++++++++++++++ u/trace/logger.ts | 86 ++++++++++++++++++++++++++++++++++++++++ u/trace/mod.ts | 3 ++ u/trace/trace.ts | 34 ++++++++++++++++ 18 files changed, 374 insertions(+) create mode 100644 u/deno.json create mode 100644 u/fn/callable.ts create mode 100644 u/fn/either.ts create mode 100644 u/fn/mod.ts create mode 100644 u/leftpadesque/debug.ts create mode 100644 u/leftpadesque/mod.ts create mode 100644 u/leftpadesque/object.ts create mode 100644 u/leftpadesque/prepend.ts create mode 100644 u/mod.ts create mode 100644 u/process/env.ts create mode 100644 u/process/mod.ts create mode 100644 u/process/run.ts create mode 100644 u/process/validate_identifier.ts create mode 100644 u/server/mod.ts create mode 100644 u/trace/itrace.ts create mode 100644 u/trace/logger.ts create mode 100644 u/trace/mod.ts create mode 100644 u/trace/trace.ts (limited to 'u') diff --git a/u/deno.json b/u/deno.json new file mode 100644 index 0000000..46e74d6 --- /dev/null +++ b/u/deno.json @@ -0,0 +1,6 @@ +{ + "name": "@emprespresso/utils", + "version": "0.1.0", + "exports": "./mod.ts", + "workspace": ["./*"] +} diff --git a/u/fn/callable.ts b/u/fn/callable.ts new file mode 100644 index 0000000..2749947 --- /dev/null +++ b/u/fn/callable.ts @@ -0,0 +1,15 @@ +// deno-lint-ignore no-explicit-any +export interface Callable { + (...args: Array): T; +} + +export interface Supplier extends Callable { + (): T; +} + +export interface SideEffect extends Callable { +} + +export interface Mapper extends Callable { + (t: T): U; +} diff --git a/u/fn/either.ts b/u/fn/either.ts new file mode 100644 index 0000000..eaf77fd --- /dev/null +++ b/u/fn/either.ts @@ -0,0 +1,62 @@ +import type { Mapper, Supplier } from "./mod.ts"; + +export interface IEither { + mapBoth: ( + errBranch: Mapper, + okBranch: Mapper, + ) => IEither; + flatMap: (mapper: Mapper>) => IEither; + mapRight: (mapper: Mapper) => IEither; + mapLeft: (mapper: Mapper) => IEither; +} + +export class Either implements IEither { + private constructor(private readonly err?: E, private readonly ok?: T) {} + + public mapBoth( + errBranch: Mapper, + okBranch: Mapper, + ): Either { + if (this.err) return Either.left(errBranch(this.err)); + return Either.right(okBranch(this.ok!)); + } + + public flatMap(mapper: Mapper>) { + if (this.ok) return mapper(this.ok); + return Either.left(this.err!); + } + + public mapRight(mapper: Mapper): IEither { + if (this.ok) return Either.right(mapper(this.ok)); + return Either.left(this.err!); + } + + public mapLeft(mapper: Mapper) { + if (this.err) return Either.left(mapper(this.err)); + return Either.right(this.ok!); + } + + static left(e: E) { + return new Either(e); + } + + static right(t: T) { + return new Either(undefined, t); + } + + static fromFailable(s: Supplier) { + try { + return Either.right(s()); + } catch (e) { + return Either.left(e as E); + } + } + + static async fromFailableAsync(s: Promise) { + try { + return Either.right(await s); + } catch (e) { + return Either.left(e as E); + } + } +} diff --git a/u/fn/mod.ts b/u/fn/mod.ts new file mode 100644 index 0000000..f0fbe88 --- /dev/null +++ b/u/fn/mod.ts @@ -0,0 +1,2 @@ +export * from "./callable.ts"; +export * from "./either.ts"; diff --git a/u/leftpadesque/debug.ts b/u/leftpadesque/debug.ts new file mode 100644 index 0000000..a9da1f3 --- /dev/null +++ b/u/leftpadesque/debug.ts @@ -0,0 +1,11 @@ +const _hasEnv = !Deno.permissions.querySync({ name: "env" }); + +const _env: "development" | "production" = + _hasEnv && (Deno.env.get("ENVIRONMENT") ?? "").toLowerCase().includes("prod") + ? "production" + : "development"; +export const isProd = () => _env === "production"; + +const _debug = !isProd() || (_hasEnv && + ["y", "t"].some((Deno.env.get("DEBUG") ?? "").toLowerCase().startsWith)); +export const isDebug = () => _debug; diff --git a/u/leftpadesque/mod.ts b/u/leftpadesque/mod.ts new file mode 100644 index 0000000..801846a --- /dev/null +++ b/u/leftpadesque/mod.ts @@ -0,0 +1,3 @@ +export * from "./object.ts"; +export * from "./prepend.ts"; +export * from "./debug.ts"; diff --git a/u/leftpadesque/object.ts b/u/leftpadesque/object.ts new file mode 100644 index 0000000..73f7f80 --- /dev/null +++ b/u/leftpadesque/object.ts @@ -0,0 +1,2 @@ +export const isObject = (o: unknown): o is object => + typeof o === "object" && !Array.isArray(o) && !!o; diff --git a/u/leftpadesque/prepend.ts b/u/leftpadesque/prepend.ts new file mode 100644 index 0000000..9b77aff --- /dev/null +++ b/u/leftpadesque/prepend.ts @@ -0,0 +1,4 @@ +export const prependWith = (arr: string[], prep: string) => + Array(arr.length * 2).fill(0) + .map((_, i) => i % 2 === 0) + .map((isPrep, i) => isPrep ? prep : arr[i]); diff --git a/u/mod.ts b/u/mod.ts new file mode 100644 index 0000000..fab6804 --- /dev/null +++ b/u/mod.ts @@ -0,0 +1,4 @@ +export * from "./fn/mod.ts"; +export * from "./leftpadesque/mod.ts"; +export * from "./process/mod.ts"; +export * from "./trace/mod.ts"; diff --git a/u/process/env.ts b/u/process/env.ts new file mode 100644 index 0000000..e80ec4a --- /dev/null +++ b/u/process/env.ts @@ -0,0 +1,10 @@ +import { Either, type IEither } from "@emprespresso/utils"; + +export const getRequiredEnv = (name: string): IEither => + Either.fromFailable(() => { + const value = Deno.env.get(name); // could throw when no permission. + if (!value) { + throw new Error(`environment variable "${name}" is required D:`); + } + return value; + }); diff --git a/u/process/mod.ts b/u/process/mod.ts new file mode 100644 index 0000000..3f02d46 --- /dev/null +++ b/u/process/mod.ts @@ -0,0 +1,3 @@ +export * from "./env.ts"; +export * from "./run.ts"; +export * from "./validate_identifier.ts"; diff --git a/u/process/run.ts b/u/process/run.ts new file mode 100644 index 0000000..6dc37d0 --- /dev/null +++ b/u/process/run.ts @@ -0,0 +1,40 @@ +import { Either, type Traceable } from "@emprespresso/utils"; + +export class ProcessError extends Error {} +export const getStdout = async ( + { item: cmd, logger: _logger }: Traceable, + options: Deno.CommandOptions = {}, +): Promise> => { + const logger = _logger.addTracer(() => "[getStdout]"); + + logger.log(`:> im gonna run this command!`, cmd); + const [exec, ...args] = (typeof cmd === "string") ? cmd.split(" ") : cmd; + const command = new Deno.Command(exec, { + args, + stdout: "piped", + stderr: "piped", + ...options, + }); + + try { + const { code, stdout, stderr } = await command.output(); + const stdoutText = new TextDecoder().decode(stdout); + const stderrText = new TextDecoder().decode(stderr); + + if (code !== 0) { + logger.error(`i weceived an exit code of ${code} i wanna zeroooo :<`); + return Either.left( + new ProcessError(`command failed\n${stderrText}`), + ); + } + + logger.log("yay! i got code 0 :3", cmd); + return Either.right(stdoutText); + } catch (e) { + logger.error(`o.o wat`, e); + if (e instanceof Error) { + return Either.left(e); + } + throw new Error("unknown error " + e); + } +}; diff --git a/u/process/validate_identifier.ts b/u/process/validate_identifier.ts new file mode 100644 index 0000000..ec8b77b --- /dev/null +++ b/u/process/validate_identifier.ts @@ -0,0 +1,17 @@ +import { Either } from "./mod.ts"; + +export const validateIdentifier = (token: string) => { + return (/^[a-zA-Z0-9_\-:. \/]+$/).test(token) && !token.includes(".."); +}; + +// ensure {@param obj} is a Record with stuff that won't +// have the potential for shell injection, just to be super safe. +export const validateExecutionEntries = ( + obj: Record, +): Either, Record> => { + const invalidEntries = Object.entries(obj).filter((e) => + !e.every((x) => typeof x === "string" && validateIdentifier(x)) + ); + if (invalidEntries.length > 0) return Either.left(invalidEntries); + return Either.right(> obj); +}; diff --git a/u/server/mod.ts b/u/server/mod.ts new file mode 100644 index 0000000..e69de29 diff --git a/u/trace/itrace.ts b/u/trace/itrace.ts new file mode 100644 index 0000000..b483067 --- /dev/null +++ b/u/trace/itrace.ts @@ -0,0 +1,72 @@ +import { Mapper, SideEffect } from "../fn/mod.ts"; + +export interface ITrace { + addTrace: Mapper>; + trace: SideEffect; +} + +export type ITraceableTuple = [T, Trace]; +export type ITraceableMapper> = ( + w: W, +) => U; + +export interface ITraceable { + readonly item: T; + readonly trace: ITrace; + + move(u: U): ITraceable; + map: ( + mapper: ITraceableMapper, + ) => ITraceable; + bimap: ( + mapper: ITraceableMapper>, + ) => ITraceable; + peek: (peek: ITraceableMapper) => ITraceable; + flatMap: ( + mapper: ITraceableMapper>, + ) => ITraceable; + flatMapAsync( + mapper: ITraceableMapper>>, + ): ITraceable, Trace>; +} + +export class TraceableImpl implements ITraceable { + protected constructor( + readonly item: T, + readonly trace: ITrace, + ) {} + + public map(mapper: ITraceableMapper) { + const result = mapper(this); + return new TraceableImpl(result, this.trace); + } + + public flatMap( + mapper: ITraceableMapper>, + ): ITraceable { + return mapper(this); + } + + public flatMapAsync( + mapper: ITraceableMapper>>, + ): ITraceable, L> { + return new TraceableImpl( + mapper(this).then(({ item }) => item), + this.trace, + ); + } + + public peek(peek: ITraceableMapper) { + peek(this); + return this; + } + + public move(t: Tt): ITraceable { + return this.map(() => t); + } + + public bimap(mapper: ITraceableMapper>) { + const [item, trace] = mapper(this); + return new TraceableImpl(item, this.trace.addTrace(trace)); + } +} diff --git a/u/trace/logger.ts b/u/trace/logger.ts new file mode 100644 index 0000000..79da367 --- /dev/null +++ b/u/trace/logger.ts @@ -0,0 +1,86 @@ +import { + isDebug, + isObject, + type ITrace, + type SideEffect, + type Supplier, +} from "@emprespresso/utils"; + +export interface ILogger { + log: (...args: unknown[]) => void; + debug: (...args: unknown[]) => void; + warn: (...args: unknown[]) => void; + error: (...args: unknown[]) => void; +} +export type ILoggerLevel = "UNKNOWN" | "INFO" | "WARN" | "DEBUG" | "ERROR"; +const logLevelOrder: Array = ["DEBUG", "INFO", "WARN", "ERROR"]; +const defaultAllowedLevels = () => + [ + "UNKNOWN", + ...(isDebug() ? ["DEBUG"] : []), + "INFO", + "WARN", + "ERROR", + ] as Array; + +export const logWithLevel = ( + logger: ILogger, + level: ILoggerLevel, +): SideEffect => { + switch (level) { + case "UNKNOWN": + case "INFO": + return logger.log; + case "DEBUG": + return logger.debug; + case "WARN": + return logger.warn; + case "ERROR": + return logger.error; + } +}; + +export const LoggerImpl = console; + +export type LogTraceSupplier = string | Supplier | { + level: ILoggerLevel; +}; + +const foldTraces = (traces: Array) => { + const { line, level } = traces.reduce( + (acc: { line: string; level: number }, t) => { + if (isObject(t) && "level" in t) { + return { + ...acc, + level: Math.max(logLevelOrder.indexOf(t.level), acc.level), + }; + } + const prefix = [ + acc.line, + typeof t === "function" ? t() : t, + ].join(" "); + return { ...acc, prefix }; + }, + { line: "", level: -1 }, + ); + return { line, level: logLevelOrder[level] ?? "UNKNOWN" }; +}; + +const defaultTrace = () => `[${new Date().toISOString()}]`; +export const LogTrace = ( + logger: ILogger, + traces: Array = [defaultTrace], + allowedLevels: Supplier> = defaultAllowedLevels, + defaultLevel: ILoggerLevel = "INFO", +): ITrace => { + return { + addTrace: (trace: LogTraceSupplier) => + LogTrace(logger, traces.concat(trace)), + trace: (trace: LogTraceSupplier) => { + const { line, level: _level } = foldTraces(traces.concat(trace)); + if (!allowedLevels().includes(_level)) return; + const level = _level === "UNKNOWN" ? defaultLevel : _level; + logWithLevel(logger, level)(`[${level}]${line}`); + }, + }; +}; diff --git a/u/trace/mod.ts b/u/trace/mod.ts new file mode 100644 index 0000000..9c42858 --- /dev/null +++ b/u/trace/mod.ts @@ -0,0 +1,3 @@ +export * from "./itrace.ts"; +export * from "./logger.ts"; +export * from "./trace.ts"; diff --git a/u/trace/trace.ts b/u/trace/trace.ts new file mode 100644 index 0000000..5d5c59b --- /dev/null +++ b/u/trace/trace.ts @@ -0,0 +1,34 @@ +import type { Callable } from "@emprespresso/utils"; +import { + type ITraceableMapper, + type ITraceableTuple, + TraceableImpl, + TraceableLogger, +} from "./mod.ts"; + +export class Traceable extends TraceableImpl { + static from(t: T) { + return new Traceable(t, new TraceableLogger()); + } + + static withFunctionTrace( + f: F, + ): ITraceableMapper> { + return (t) => [t.item, f.name]; + } + + static withClassTrace( + c: C, + ): ITraceableMapper> { + return (t) => [t.item, c.constructor.name]; + } + + static promiseify( + mapper: ITraceableMapper, + ): ITraceableMapper, TraceableLogger, Promise> { + return (traceablePromise) => + traceablePromise.flatMapAsync(async (t) => + t.move(await t.item).map(mapper) + ).item; + } +} -- cgit v1.2.3-70-g09d2