eddev 0.3.38 → 2.0.0-beta.10

package/dist/node/utils/report-builder.js

@@ -0,0 +1,51 @@
+import chalk from "chalk";
+import { inspect } from "util";
+export function createReportBuilder() {
+    const lines = [];
+    function stringify(...values) {
+        return values
+            .map((v) => {
+            if (typeof v === "string" || typeof v === "number")
+                return v;
+            if (v === null || v === undefined || typeof v === "boolean")
+                return String(v);
+            if (v instanceof Error)
+                return chalk.red(`${v.name}: ${v.message}`) + "\n" + v.stack;
+            if (v instanceof Date)
+                return v.toISOString();
+            if (typeof v === "object")
+                return inspect(v, { depth: 2, colors: true });
+            return String(v);
+        })
+            .join(" ");
+    }
+    return {
+        log(...values) {
+            lines.push(stringify(...values));
+            return this;
+        },
+        warn(...values) {
+            lines.push(chalk.yellow("⚠ ") + stringify(...values));
+            return this;
+        },
+        fail(...values) {
+            lines.push(chalk.redBright("✖ ") + stringify(...values));
+            return this;
+        },
+        info(...values) {
+            lines.push(chalk.blueBright("ℹ ") + stringify(...values));
+            return this;
+        },
+        help(...values) {
+            lines.push(chalk.cyan("? ") + stringify(...values));
+            return this;
+        },
+        success(...values) {
+            lines.push(chalk.green("✔ ") + stringify(...values));
+            return this;
+        },
+        toString() {
+            return lines.join("\n");
+        },
+    };
+}

package/dist/node/utils/self-signed-cert.d.ts

@@ -0,0 +1,4 @@
+export declare function ensureSelfSignedCert(hostname: string, rootDir: string): Promise<{
+    certFile: string;
+    keyFile: string;
+}>;

package/dist/node/utils/self-signed-cert.js

@@ -0,0 +1,35 @@
+import { serverlessLog } from "../compiler/dev-server.js";
+import { fs } from "./fs.js";
+import { createCA, createCert } from "mkcert";
+export async function ensureSelfSignedCert(hostname, rootDir) {
+    const certFile = `${rootDir}/.eddev/certs/${hostname}.crt`;
+    const keyFile = `${rootDir}/.eddev/certs/${hostname}.key`;
+    if ((await fs.exists(certFile)) && (await fs.exists(keyFile))) {
+        return {
+            certFile,
+            keyFile,
+        };
+    }
+    console.info("Creating a self-signed certificate for local development.");
+    const ca = await createCA({
+        organization: "ED. Digital",
+        countryCode: "AU",
+        state: "New South Wales",
+        locality: "Sydney",
+        validity: 365 * 10,
+    });
+    const pems = await createCert({
+        ca: { key: ca.key, cert: ca.cert },
+        domains: [hostname],
+        validity: 365 * 10,
+    });
+    await fs.mkdirp(`${rootDir}/.eddev/certs`);
+    await fs.writeFile(certFile, pems.cert);
+    await fs.writeFile(keyFile, pems.key);
+    serverlessLog.help(`A new self-signed certificate has been created for ${hostname}! Please add the certificate to your keychain.`);
+    serverlessLog.help(`Certificate: ${certFile.replace(rootDir, "")}`);
+    return {
+        certFile,
+        keyFile,
+    };
+}

package/dist/node/utils/stateful-log.d.ts

@@ -0,0 +1,65 @@
+import type { ZodError } from "zod";
+export type LogSeverity = "log" | "verbose" | "info" | "warn" | "error" | "fail" | "success" | "help";
+export type LogEntry = {
+    id: number;
+    type: "entry";
+    kind: LogSeverity;
+    time: number;
+    items: any[];
+};
+export type LogGroup = {
+    id: number;
+    type: "group";
+    kind: LogSeverity;
+    label: string;
+    time: number;
+    entries: LogGroupOrEntry[];
+};
+export type LogGroupOrEntry = LogGroup | LogEntry;
+export type LogStatus = LogSeverity | "working";
+export declare class StatefulLog<TState> {
+    entries: LogGroupOrEntry[];
+    groupStack: LogGroup[];
+    currentGroup?: LogGroup;
+    hasWarnings: boolean;
+    hasErrors: boolean;
+    startTime: number;
+    label: string;
+    shortName: string;
+    status: LogStatus;
+    state: TState | null;
+    needsFlush?: boolean;
+    constructor(opts: {
+        label: string;
+        shortName?: string;
+    });
+    private subscribers;
+    resetLog(): void;
+    clear(): void;
+    copy(log: StatefulLog<any>): void;
+    flush(): void;
+    getDuration(): number;
+    captureLog(): LogGroupOrEntry[];
+    subscribe(fn: (self: StatefulLog<TState>) => void): () => void;
+    setState(state: TState): void;
+    setWorking(working: boolean, status?: LogStatus): void;
+    setStatus(status: LogStatus): void;
+    notifySubscribers(): void;
+    log(...messages: any[]): void;
+    verbose(...messages: any[]): void;
+    info(...messages: any[]): void;
+    warn(...messages: any[]): void;
+    error(...messages: any[]): void;
+    zodError(err: ZodError): void;
+    fail(...messages: any[]): void;
+    success(...messages: any[]): void;
+    help(...messages: any[]): void;
+    private addLogEntry;
+    startGroup(label: string, kind?: LogSeverity): void;
+    addWholeGroup(label: string, kind: LogSeverity | undefined, entries: {
+        kind: LogSeverity;
+        message: any[];
+    }[]): void;
+    endGroup(): void;
+}
+export declare function createConsole<TState>(label: string, shortName?: string): StatefulLog<TState>;

package/dist/node/utils/stateful-log.js

@@ -0,0 +1,223 @@
+import { cliMode } from "../cli/cli-mode.js";
+import { eachFormattedZodError } from "./format-zod-error.js";
+import chalk from "chalk";
+let logId = 0;
+const getID = () => logId++;
+export class StatefulLog {
+    entries = [];
+    groupStack = [];
+    currentGroup;
+    hasWarnings = false;
+    hasErrors = false;
+    startTime = Date.now();
+    label;
+    shortName;
+    status = "working";
+    state = null;
+    needsFlush;
+    constructor(opts) {
+        this.label = opts.label;
+        this.shortName = opts.shortName ?? opts.label;
+    }
+    subscribers = [];
+    resetLog() {
+        this.entries = [];
+        this.groupStack = [];
+        this.currentGroup = undefined;
+        this.hasErrors = false;
+        this.hasWarnings = false;
+        this.startTime = Date.now();
+        this.notifySubscribers();
+    }
+    clear() {
+        this.entries = [];
+        this.groupStack = [];
+        this.currentGroup = undefined;
+        this.hasErrors = false;
+        this.hasWarnings = false;
+        this.notifySubscribers();
+    }
+    copy(log) {
+        this.entries = log.entries;
+        this.groupStack = log.groupStack;
+        this.currentGroup = log.currentGroup;
+        this.hasErrors = log.hasErrors;
+        this.hasWarnings = log.hasWarnings;
+        this.startTime = log.startTime;
+        this.status = log.status;
+        this.state = log.state;
+        this.notifySubscribers();
+    }
+    flush() {
+        this.needsFlush = false;
+        this.notifySubscribers();
+    }
+    getDuration() {
+        const last = this.entries[this.entries.length - 1];
+        if (!last)
+            return 0;
+        return last.time - this.startTime;
+    }
+    captureLog() {
+        const entries = this.entries;
+        return [...entries];
+    }
+    subscribe(fn) {
+        this.subscribers.push(fn);
+        return () => {
+            this.subscribers = this.subscribers.filter((f) => f !== fn);
+        };
+    }
+    setState(state) {
+        this.state = state;
+        this.notifySubscribers();
+    }
+    setWorking(working, status) {
+        if (status) {
+            this.setStatus(status);
+        }
+        if (working) {
+            this.setStatus("working");
+        }
+        else {
+            this.setStatus(this.hasErrors ? "error" : this.hasWarnings ? "warn" : "success");
+        }
+    }
+    setStatus(status) {
+        this.status = status;
+        this.notifySubscribers();
+    }
+    notifySubscribers() {
+        this.subscribers.forEach((fn) => fn(this));
+    }
+    log(...messages) {
+        this.addLogEntry("log", ...messages);
+        this.notifySubscribers();
+    }
+    verbose(...messages) {
+        if (cliMode.verbose) {
+            this.addLogEntry("verbose", ...messages);
+        }
+        this.notifySubscribers();
+    }
+    info(...messages) {
+        this.addLogEntry("info", ...messages);
+        this.notifySubscribers();
+    }
+    warn(...messages) {
+        this.addLogEntry("warn", ...messages);
+        this.hasWarnings = true;
+        this.notifySubscribers();
+    }
+    error(...messages) {
+        this.addLogEntry("error", ...messages);
+        this.hasErrors = true;
+        this.notifySubscribers();
+    }
+    zodError(err) {
+        eachFormattedZodError(err).forEach((msg) => {
+            this.fail(msg);
+        });
+    }
+    fail(...messages) {
+        this.addLogEntry("fail", ...messages);
+        this.hasWarnings = true;
+        this.notifySubscribers();
+    }
+    success(...messages) {
+        this.addLogEntry("success", ...messages);
+        this.notifySubscribers();
+    }
+    help(...messages) {
+        this.addLogEntry("help", ...messages);
+        this.notifySubscribers();
+    }
+    addLogEntry(kind, ...messages) {
+        if (cliMode.interactive) {
+            const entry = {
+                id: getID(),
+                type: "entry",
+                kind,
+                time: Date.now(),
+                items: messages,
+            };
+            if (this.currentGroup) {
+                this.currentGroup.entries.push(entry);
+            }
+            else {
+                this.entries.push(entry);
+            }
+            this.notifySubscribers();
+        }
+        else {
+            console.log(chalk.grey(`[${this.shortName}]`), ...messages);
+        }
+    }
+    startGroup(label, kind = "log") {
+        if (cliMode.interactive) {
+            if (kind === "error" || kind === "fail") {
+                this.hasErrors = true;
+            }
+            else if (kind === "warn") {
+                this.hasWarnings = true;
+            }
+            const group = {
+                id: getID(),
+                type: "group",
+                kind: kind,
+                label,
+                time: Date.now(),
+                entries: [],
+            };
+            if (this.currentGroup) {
+                this.currentGroup.entries.push(group);
+            }
+            else {
+                this.entries.push(group);
+            }
+            this.currentGroup = group;
+            this.groupStack.push(group);
+            this.notifySubscribers();
+        }
+        else {
+            console.log("<" + label + ">");
+        }
+    }
+    addWholeGroup(label, kind = "log", entries) {
+        this.entries.push({
+            id: getID(),
+            type: "group",
+            kind,
+            label,
+            time: Date.now(),
+            entries: entries.map((entry) => ({
+                id: getID(),
+                type: "entry",
+                kind: entry.kind,
+                time: Date.now(),
+                items: entry.message,
+            })),
+        });
+        if (kind === "error" || kind === "fail") {
+            this.hasErrors = true;
+        }
+        else if (kind === "warn") {
+            this.hasWarnings = true;
+        }
+        this.notifySubscribers();
+    }
+    endGroup() {
+        if (cliMode.interactive) {
+            if (this.currentGroup) {
+                this.currentGroup = undefined;
+                this.groupStack.pop();
+            }
+        }
+    }
+}
+export function createConsole(label, shortName) {
+    return new StatefulLog({
+        label,
+        shortName,
+    });
+}

package/dist/node/utils/ts-export-extractor.d.ts

@@ -0,0 +1,9 @@
+export declare class ExportExtractor {
+    exportName: string;
+    cache: Map<string, any>;
+    constructor(exportName: string);
+    extract(file: string, contents: string, force?: boolean): any;
+    private extractExpressionValue;
+    invalidate(name: string): void;
+}
+export declare const metaExtractor: ExportExtractor;

package/dist/node/utils/ts-export-extractor.js

@@ -0,0 +1,71 @@
+import ts from "typescript";
+export class ExportExtractor {
+    exportName;
+    cache = new Map();
+    constructor(exportName) {
+        this.exportName = exportName;
+        // this.program
+    }
+    extract(file, contents, force = false) {
+        if (this.cache.has(file) && !force)
+            return this.cache.get(file);
+        let result = null;
+        // const program = ts.createProgram([file], {
+        //   jsx: ts.JsxEmit.React,
+        // })
+        const source = ts.createSourceFile(file, contents, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+        if (source) {
+            ts.forEachChild(source, (node) => {
+                /**
+                 * export const meta = any
+                 */
+                if (ts.isVariableStatement(node) && node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+                    node.declarationList.declarations.forEach((node) => {
+                        if (ts.isIdentifier(node.name) && node.name.text === this.exportName) {
+                            if (node.initializer) {
+                                result = this.extractExpressionValue(node.initializer);
+                            }
+                        }
+                    });
+                }
+            });
+        }
+        this.cache.set(file, result);
+        return result;
+    }
+    extractExpressionValue(node) {
+        if (ts.isObjectLiteralExpression(node)) {
+            const obj = {};
+            for (const prop of node.properties) {
+                if (ts.isPropertyAssignment(prop)) {
+                    if (ts.isIdentifier(prop.name)) {
+                        obj[prop.name.text] = this.extractExpressionValue(prop.initializer);
+                    }
+                }
+            }
+            return obj;
+        }
+        else if (ts.isArrayLiteralExpression(node)) {
+            return node.elements.map((e) => this.extractExpressionValue(e));
+        }
+        else if (ts.isStringLiteral(node)) {
+            return node.text;
+        }
+        else if (ts.isNumericLiteral(node)) {
+            return parseFloat(node.text);
+        }
+        else if (node.kind === ts.SyntaxKind.TrueKeyword) {
+            return true;
+        }
+        else if (node.kind === ts.SyntaxKind.FalseKeyword) {
+            return false;
+        }
+        else {
+            return undefined;
+        }
+    }
+    invalidate(name) {
+        this.cache.delete(name);
+    }
+}
+export const metaExtractor = new ExportExtractor("meta");

package/dist/node/utils/watch-file-tree.d.ts

@@ -0,0 +1,11 @@
+type FileList = string[];
+type Disposer = () => void;
+export type FileWatchEvent = "added" | "deleted" | "changed";
+export type FileEvent = {
+    type: FileWatchEvent;
+    file: string;
+};
+export declare function watchFileTree(pattern: string | string[], callback: (files: FileList, event?: FileEvent) => void): Promise<Disposer>;
+export declare function watchFileTreeForChanges(pattern: string | string[], callback: (event: FileEvent) => void): Promise<Disposer>;
+export declare function getFileTree(pattern: string | string[]): Promise<FileList>;
+export {};

package/dist/node/utils/watch-file-tree.js

@@ -0,0 +1,58 @@
+import chokidar from "chokidar";
+import { globby } from "globby";
+export function watchFileTree(pattern, callback) {
+    const files = [];
+    let ready = false;
+    return new Promise((resolve) => {
+        const watcher = chokidar
+            .watch(pattern)
+            .on("add", (path) => {
+            files.push(path);
+            if (ready)
+                callback(files, { type: "added", file: path });
+        })
+            .on("unlink", (path) => {
+            const i = files.indexOf(path);
+            if (i !== -1)
+                files.splice(i, 1);
+            if (ready)
+                callback(files, { type: "deleted", file: path });
+        })
+            .on("change", (path) => {
+            if (ready)
+                callback(files, { type: "changed", file: path });
+        })
+            .on("ready", () => {
+            ready = true;
+            callback(files);
+            resolve(() => {
+                watcher.close();
+            });
+        });
+    });
+}
+export function watchFileTreeForChanges(pattern, callback) {
+    let ready = false;
+    return new Promise((resolve) => {
+        const watcher = chokidar
+            .watch(pattern)
+            .on("add", (path) => {
+            if (ready)
+                callback({ type: "added", file: path });
+        })
+            .on("unlink", (path) => {
+            if (ready)
+                callback({ type: "deleted", file: path });
+        })
+            .on("change", (path) => {
+            if (ready)
+                callback({ type: "changed", file: path });
+        })
+            .on("ready", () => {
+            ready = true;
+        });
+    });
+}
+export function getFileTree(pattern) {
+    return globby(pattern);
+}