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

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,39 @@
 {
   "name": "@aventara/build",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-rc.8",
+  "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.18.0 || >=24.2.0"
+  },
+  "bin": {
+    "aventara-build": "./dist/aventara-build.bin.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE-ADDITIONAL-PERMISSION.md",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "jiti": "2.7.0"
+  },
+  "peerDependencies": {
+    "@aventara/core": "1.0.0-rc.8",
+    "typescript": ">=5.7.0 <7"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@aventara/core": "1.0.0-rc.8",
+    "@types/node": "24.10.1",
+    "typescript": "^5.9.2"
+  },
+  "scripts": {
+    "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"
+  }
 }