@aventara/build 0.0.0-stage → 1.0.0-rc.11

package/dist/project/project-modules.loader.js

@@ -0,0 +1,117 @@
+import { statSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { createJiti } from "jiti";
+import { AvBuildError } from "../build.error.js";
+const EXTENSIONS = [".js", ".ts", ".mjs", ".cjs", ".mts", ".cts"];
+const EXTENSIONS_AS_LISTED = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+const SERVER_MARKERS = { "server-only": {} };
+const CONFIG_EXPORTS = ["aventaraConfig", "default"];
+function projectFile(projectDirectory, module, layout) {
+    const present = EXTENSIONS.map((extension) => `${module}${extension}`).filter((file) => statSync(path.join(projectDirectory, file), {
+        throwIfNoEntry: false,
+    })?.isFile() === true);
+    if (present.length === 0) {
+        const [first, ...others] = EXTENSIONS_AS_LISTED;
+        throw new AvBuildError(`no ${module}${first}, ${others.slice(0, -1).join(", ")} or ${others.at(-1)} in ${projectDirectory}, where ${layout.described} keeps it. Run aventara-build from the project's root (the aventara:prepare script does).`);
+    }
+    if (present.length > 1) {
+        throw new AvBuildError(`${present.slice(0, -1).join(", ")} and ${present.at(-1)} are all ${module}; keep one and delete the other${present.length > 2 ? "s" : ""}.`);
+    }
+    return present[0];
+}
+async function evaluate(jiti, projectDirectory, file) {
+    try {
+        return await jiti.import(path.join(projectDirectory, file));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new AvBuildError(`${file} could not be run: ${message.split("\n", 1)[0]}. aventara-build runs it at build time, so its top-level code must run without a server, a database client or a request.`, { cause: error });
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function configOf(file, namespace) {
+    const name = CONFIG_EXPORTS.find((candidate) => Object.hasOwn(namespace, candidate));
+    if (name === undefined) {
+        throw new AvBuildError(`${file} exports neither \`aventaraConfig\` nor a default: export the configuration as \`export const aventaraConfig = { … } as const\`.`);
+    }
+    const shown = name === "default" ? "its default export" : `\`${name}\``;
+    const value = namespace[name];
+    if (typeof value === "function") {
+        throw new AvBuildError(`${shown} in ${file} is a function. aventara-build runs the configuration without a database client, so export the configuration itself, as a value without \`adapter\`, and join the adapter where the framework is created (\`{ ...aventaraConfig, adapter }\`).`);
+    }
+    if (!isRecord(value)) {
+        throw new AvBuildError(`${shown} in ${file} is not an object: it must be the configuration, \`{ api, … } as const\`.`);
+    }
+    if (Object.hasOwn(value, "adapter")) {
+        throw new AvBuildError(`${shown} in ${file} builds its own adapter (\`adapter\`). Export the configuration without it and join the adapter where the framework is created: \`{ ...aventaraConfig, adapter: await createPrismaAdapter({ ...adapter, client }) }\`.`);
+    }
+    if (Object.hasOwn(value, "prebuilt")) {
+        throw new AvBuildError(`${shown} in ${file} sets \`prebuilt\`, which is this build's output: pass it where the framework is created.`);
+    }
+    return value;
+}
+const TRANSACTIONS = [
+    "interactive",
+    "none",
+];
+function descriptionOf(file, namespace) {
+    const shape = "`export default describePrismaAdapter({ discovery, provider, driver })` (or your adapter's describe function)";
+    if (!Object.hasOwn(namespace, "default")) {
+        throw new AvBuildError(`${file} has no default export; it must be the adapter's description: ${shape}.`);
+    }
+    const value = namespace.default;
+    if (!isRecord(value)) {
+        throw new AvBuildError(`${file}'s default export is not an object; it must be the adapter's description: ${shape}.`);
+    }
+    const wrong = (member, expected) => new AvBuildError(`${file}'s default export is not an adapter description: its \`${member}\` is not ${expected}. It must be ${shape}.`);
+    if (!isRecord(value.model)) {
+        throw wrong("model", "an object");
+    }
+    if (!TRANSACTIONS.includes(value.transactions)) {
+        throw wrong("transactions", '"interactive" or "none"');
+    }
+    for (const member of ["referentialActions", "computedFields"]) {
+        if (value[member] !== undefined && !isRecord(value[member])) {
+            throw wrong(member, "an object");
+        }
+    }
+    if (value.sqlStatements !== undefined &&
+        typeof value.sqlStatements !== "boolean") {
+        throw wrong("sqlStatements", "a boolean");
+    }
+    return value;
+}
+async function projectCore(jiti) {
+    try {
+        const [core, internal] = await Promise.all([
+            jiti.import("@aventara/core"),
+            jiti.import("@aventara/core/internal"),
+        ]);
+        return { core, internal };
+    }
+    catch (error) {
+        throw new AvBuildError(`@aventara/core could not be loaded from the project (${error instanceof Error ? error.message.split("\n", 1)[0] : String(error)}); install it beside @aventara/build.`, { cause: error });
+    }
+}
+export function findProjectModules(projectDirectory, layout) {
+    return {
+        configFile: projectFile(projectDirectory, layout.config, layout),
+        adapterFile: projectFile(projectDirectory, layout.adapter, layout),
+    };
+}
+export async function loadProjectModules(projectDirectory, { configFile, adapterFile }) {
+    const jiti = createJiti(pathToFileURL(path.join(projectDirectory, "package.json")).href, {
+        moduleCache: false,
+        fsCache: false,
+        interopDefault: false,
+        nativeModules: ["@aventara/core"],
+        virtualModules: SERVER_MARKERS,
+    });
+    const project = await projectCore(jiti);
+    const config = configOf(configFile, await evaluate(jiti, projectDirectory, configFile));
+    const description = descriptionOf(adapterFile, await evaluate(jiti, projectDirectory, adapterFile));
+    return { ...project, configFile, config, adapterFile, description };
+}

package/dist/project/tsconfig.reader.js

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import { AvBuildError } from "../build.error.js";
+function defaultOptions() {
+    return {
+        target: ts.ScriptTarget.ES2022,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        strict: true,
+    };
+}
+export function projectCompilerOptions(projectDirectory) {
+    assertClassicCompilerApi();
+    const tsconfig = ts.findConfigFile(projectDirectory, ts.sys.fileExists, "tsconfig.json");
+    if (tsconfig === undefined) {
+        return defaultOptions();
+    }
+    const read = ts.readConfigFile(tsconfig, ts.sys.readFile);
+    if (read.error !== undefined) {
+        return defaultOptions();
+    }
+    return ts.parseJsonConfigFileContent(read.config, ts.sys, path.dirname(tsconfig)).options;
+}
+export function importSuffixOf(options, directory) {
+    if (options.allowImportingTsExtensions === true ||
+        options
+            .rewriteRelativeImportExtensions === true) {
+        return ".ts";
+    }
+    if (options.module === ts.ModuleKind.CommonJS ||
+        options.moduleResolution === ts.ModuleResolutionKind.Bundler) {
+        return "";
+    }
+    if (options.module === ts.ModuleKind.Node16 ||
+        options.module === ts.ModuleKind.NodeNext) {
+        return packageType(directory) === "module" ? ".js" : "";
+    }
+    return ".js";
+}
+function packageType(directory) {
+    for (let current = path.resolve(directory);;) {
+        const manifest = path.join(current, "package.json");
+        if (existsSync(manifest)) {
+            try {
+                return JSON.parse(readFileSync(manifest, "utf8")).type;
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+export function relativeSpecifier(from, to, suffix) {
+    const relative = path
+        .relative(path.dirname(from), to.replace(/\.ts$/, ""))
+        .split(path.sep)
+        .join("/");
+    return `${relative.startsWith(".") ? relative : `./${relative}`}${suffix}`;
+}
+function assertClassicCompilerApi() {
+    const compiler = ts;
+    if (typeof compiler?.createProgram === "function" &&
+        typeof compiler.findConfigFile === "function") {
+        return;
+    }
+    throw new AvBuildError(`the installed \`typescript\` ${compiler?.version ?? "(no version)"} has no classic compiler API (\`createProgram\`), which aventara-build reads the project's Resources and configuration with; install a \`typescript\` below 7.`);
+}

package/dist/resources/resource-definitions.reader.js

@@ -0,0 +1,111 @@
+import { globSync } from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import { AvBuildError } from "../build.error.js";
+export const RESOURCES_GLOB = "src/resources/**/*.resource.ts";
+export const DEFINITION_LAYERS = [
+    "root",
+    "application",
+    "client",
+    "agent",
+];
+const DEFINED_RESOURCE = "AvDefinedResource";
+function matchedFiles(projectDirectory) {
+    return globSync(RESOURCES_GLOB, { cwd: projectDirectory })
+        .map((file) => file.split(path.sep).join("/"))
+        .sort();
+}
+function listed(items) {
+    return items.length < 2
+        ? items.join("")
+        : `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
+}
+export function readResourceDefinitions(projectDirectory, options) {
+    const files = matchedFiles(projectDirectory);
+    const program = ts.createProgram({
+        rootNames: files.map((file) => path.join(projectDirectory, file)),
+        options: { ...options, noEmit: true, skipLibCheck: true },
+    });
+    const checker = program.getTypeChecker();
+    const found = new Map();
+    const places = new Map();
+    const withoutDefinition = [];
+    for (const file of files) {
+        const source = program.getSourceFile(path.join(projectDirectory, file));
+        const module = source === undefined ? undefined : checker.getSymbolAtLocation(source);
+        let defines = false;
+        for (const exported of module === undefined
+            ? []
+            : checker.getExportsOfModule(module)) {
+            const target = exported.flags & ts.SymbolFlags.Alias
+                ? checker.getAliasedSymbol(exported)
+                : exported;
+            if ((target.flags & ts.SymbolFlags.Value) === 0) {
+                continue;
+            }
+            const type = checker.getTypeOfSymbol(target);
+            if (type.aliasSymbol?.escapedName !== DEFINED_RESOURCE) {
+                continue;
+            }
+            defines = true;
+            const exportName = exported.escapedName;
+            if (!found.has(target)) {
+                const [named] = type.aliasTypeArguments ?? [];
+                if (named === undefined || !named.isStringLiteral()) {
+                    throw new AvBuildError(`\`${exportName}\` in ${file} defines no single Resource (\`${named === undefined ? "?" : checker.typeToString(named)}\`): name the Resource as a string, \`defineResource<Model>()("Post", …)\`.`);
+                }
+                const properties = new Set(type.getProperties().map((property) => property.getName()));
+                found.set(target, {
+                    resource: named.value,
+                    layers: DEFINITION_LAYERS.filter((layer) => properties.has(layer)),
+                });
+            }
+            places.set(target, [...(places.get(target) ?? []), { file, exportName }]);
+        }
+        if (!defines) {
+            withoutDefinition.push(file);
+        }
+    }
+    const byResource = new Map();
+    for (const [symbol, { resource, layers }] of found) {
+        const all = places.get(symbol) ?? [];
+        const declaredIn = symbol.declarations?.[0]?.getSourceFile().fileName;
+        const place = all.find((candidate) => declaredIn !== undefined &&
+            path.resolve(projectDirectory, candidate.file) ===
+                path.resolve(declaredIn)) ?? all[0];
+        if (place === undefined) {
+            continue;
+        }
+        byResource.set(resource, [
+            ...(byResource.get(resource) ?? []),
+            { ...place, resource, layers },
+        ]);
+    }
+    const doubled = [...byResource.entries()]
+        .filter(([, definitions]) => definitions.length > 1)
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));
+    if (doubled.length > 0) {
+        throw new AvBuildError(doubled
+            .map(([resource, definitions]) => `${resource} is defined ${definitions.length === 2 ? "twice" : `${definitions.length} times`}: by ${listed([...definitions]
+            .sort((left, right) => left.file === right.file
+            ? left.exportName < right.exportName
+                ? -1
+                : 1
+            : left.file < right.file
+                ? -1
+                : 1)
+            .map((definition) => `\`${definition.exportName}\` in ${definition.file}`))}. Keep one defineResource(${JSON.stringify(resource)}, …) and move the other's blocks into it.`)
+            .join("\n"));
+    }
+    return {
+        definitions: [...byResource.values()]
+            .map((definitions) => definitions[0])
+            .sort((left, right) => left.resource < right.resource
+            ? -1
+            : left.resource > right.resource
+                ? 1
+                : 0),
+        withoutDefinition,
+        program,
+    };
+}

package/dist/resources/resources-file.js

@@ -0,0 +1,48 @@
+import path from "node:path";
+import { relativeSpecifier, } from "../project/tsconfig.reader.js";
+import { DEFINITION_LAYERS, RESOURCES_GLOB, } from "./resource-definitions.reader.js";
+function localNames(definitions) {
+    const taken = new Set(["aventaraResources"]);
+    return definitions.map((definition) => {
+        const preferred = definition.exportName === "default"
+            ? `${definition.resource.charAt(0).toLowerCase()}${definition.resource.slice(1)}Resource`
+            : definition.exportName;
+        let name = preferred;
+        for (let index = 2; taken.has(name); index += 1) {
+            name = `${preferred}${index}`;
+        }
+        taken.add(name);
+        return name;
+    });
+}
+export function emitResourcesModule(projectDirectory, resourcesFile, definitions, suffix) {
+    const file = path.join(projectDirectory, resourcesFile);
+    const names = localNames(definitions);
+    const imports = definitions.map((definition, index) => {
+        const local = names[index];
+        const imported = definition.exportName === local
+            ? local
+            : `${definition.exportName} as ${local}`;
+        return `import { ${imported} } from ${JSON.stringify(relativeSpecifier(file, path.join(projectDirectory, definition.file), suffix))};`;
+    });
+    const layers = DEFINITION_LAYERS.flatMap((layer) => {
+        const spreads = definitions.flatMap((definition, index) => definition.layers.includes(layer)
+            ? [`...${names[index]}.${layer}`]
+            : []);
+        return layer === "root" || spreads.length > 0
+            ? [
+                `\t${layer}: {${spreads.length === 0 ? "" : ` ${spreads.join(", ")} `}},`,
+            ]
+            : [];
+    });
+    return `${[
+        `// Generated by aventara-build from ${RESOURCES_GLOB}. Do not edit: regenerate it (aventara:prepare).`,
+        ...imports,
+        "",
+        "// Each layer's `resources` tree, every `defineResource(…)` result spread into it:",
+        "// `resources: aventaraResources.root`, `client: { resources: aventaraResources.client }`.",
+        "export const aventaraResources = {",
+        ...layers,
+        "} as const;",
+    ].join("\n")}\n`;
+}

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@aventara/build",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-rc.11",
+  "license": "SEE LICENSE IN LICENSE",
+  "description": "Compiles an Aventara application's Contracts at build time, for serverless and edge cold starts.",
+  "type": "module",
+  "engines": {
+    "node": "^22.23.4 || >=24.22.1"
+  },
+  "bin": {
+    "aventara-build": "./dist/aventara-build.bin.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE-ADDITIONAL-PERMISSION.md",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "@aventara/client": "1.0.0-rc.11",
+    "jiti": "2.7.0"
+  },
+  "peerDependencies": {
+    "@aventara/core": "1.0.0-rc.11",
+    "typescript": ">=5.7.0 <7"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@aventara/core": "1.0.0-rc.11",
+    "@types/node": "24.10.1",
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "prebuild": "node ../../scripts/build/host-catalog.generator.ts --out src/project/host.catalog.generated.ts",
+    "build": "node ../../scripts/build/build-output.cleaner.ts dist && tsc -p tsconfig.json --removeComments",
+    "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
+    "test": "vitest run --typecheck --config ../../vitest.config.mts --root .",
+    "lint": "biome lint src"
+  }
 }