@sculptor/cli 0.3.2 → 0.3.4

package/dist/package-registry.js

@@ -60,6 +60,23 @@ const inferFileType = (filePath) => {
     }
     return "type";
 };
+const isRegistryTrackableFile = (filePath) => {
+    const normalized = normalizeRelativePath(filePath);
+    return (/\.(controller|service|repository|middleware|module|dto|route|type|types)\.ts$/.test(normalized) ||
+        normalized.endsWith(".route.handler.ts"));
+};
+const createPackageFileRecord = (type, filePath, registered = false, tags = []) => ({
+    type,
+    path: normalizeRelativePath(filePath),
+    registered,
+    tags: [...tags]
+});
+const normalizeFileRecord = (record) => ({
+    type: record.type ?? inferFileType(record.path),
+    path: normalizeRelativePath(record.path),
+    registered: record.registered ?? true,
+    tags: Array.isArray(record.tags) ? record.tags.map((tag) => String(tag)) : []
+});
 const inferSymbolFromFile = (filePath) => {
     const base = path.posix.basename(filePath).replace(/\.ts$/, "");
     if (base.endsWith(".route.handler")) {
@@ -128,16 +145,71 @@ const getPackageDecorator = (node) => {
     }
     return undefined;
 };
+const getPackageCallExpression = (node) => {
+    const visit = (current) => {
+        if (ts.isCallExpression(current)) {
+            const callee = current.expression;
+            if (ts.isIdentifier(callee) && callee.text === "Package") {
+                return current;
+            }
+        }
+        return ts.forEachChild(current, visit);
+    };
+    return visit(node);
+};
+const getFunctionalPackageDefinition = (sourceFile) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name)) {
+                continue;
+            }
+            const identifier = declaration.name.text;
+            if (!identifier.endsWith("PackageDefinition")) {
+                continue;
+            }
+            const initializer = declaration.initializer;
+            if (initializer && ts.isObjectLiteralExpression(initializer)) {
+                return initializer;
+            }
+        }
+    }
+    return undefined;
+};
+const resolvePackageDefinitionByName = (sourceFile, identifier) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) {
+            continue;
+        }
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || declaration.name.text !== identifier) {
+                continue;
+            }
+            if (declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
+                return declaration.initializer;
+            }
+        }
+    }
+    return undefined;
+};
 const parsePackageMetadata = (rootDir, filePath) => {
     const sourceText = fs.readFileSync(filePath, "utf8");
     const sourceFile = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     const classes = sourceFile.statements.filter(ts.isClassDeclaration);
     const decoratedClass = classes.find((node) => getPackageDecorator(node));
-    if (!decoratedClass) {
+    const decorator = decoratedClass ? getPackageDecorator(decoratedClass) : undefined;
+    const functionalCall = decorator ? undefined : getPackageCallExpression(sourceFile);
+    const functionalDefinition = decorator || functionalCall ? undefined : getFunctionalPackageDefinition(sourceFile);
+    if (!decorator && !functionalCall && !functionalDefinition) {
         return undefined;
     }
-    const decorator = getPackageDecorator(decoratedClass);
-    const argument = decorator?.arguments[0];
+    const packageCallArgument = functionalCall?.arguments[0];
+    const resolvedFunctionalArgument = packageCallArgument && ts.isIdentifier(packageCallArgument)
+        ? resolvePackageDefinitionByName(sourceFile, packageCallArgument.text)
+        : packageCallArgument;
+    const argument = decorator?.arguments[0] ?? resolvedFunctionalArgument ?? functionalDefinition;
     if (!argument || !ts.isObjectLiteralExpression(argument)) {
         throw new Error(`Malformed @Package() metadata in ${filePath}.`);
     }
@@ -156,7 +228,19 @@ const parsePackageMetadata = (rootDir, filePath) => {
         }
         return value.text;
     };
-    const name = getString("name", decoratedClass.name?.text ?? "");
+    const inferredName = decoratedClass?.name?.text ??
+        (sourceFile.statements.find(ts.isVariableStatement)?.declarationList.declarations.find((declaration) => {
+            if (!ts.isIdentifier(declaration.name)) {
+                return false;
+            }
+            const initializer = declaration.initializer;
+            if (!initializer || !ts.isCallExpression(initializer)) {
+                return false;
+            }
+            const callee = initializer.expression;
+            return ts.isIdentifier(callee) && callee.text === "Package";
+        })?.name.getText(sourceFile) ?? "");
+    const name = getString("name", inferredName);
     const packagePath = getString("path", "");
     if (!name || !packagePath) {
         throw new Error(`Malformed @Package() metadata in ${filePath}.`);
@@ -175,8 +259,18 @@ export const loadPackageRegistry = (rootDir) => {
         return { packages: {}, files: [] };
     }
     return {
-        packages: data.packages ?? {},
-        files: data.files ?? []
+        packages: Object.fromEntries(Object.entries(data.packages ?? {}).map(([name, record]) => [
+            name,
+            {
+                ...record,
+                files: (record.files ?? [])
+                    .map((file) => normalizeFileRecord(file))
+                    .filter((file) => isRegistryTrackableFile(file.path))
+            }
+        ])),
+        files: (data.files ?? [])
+            .map((file) => normalizeFileRecord(file))
+            .filter((file) => isRegistryTrackableFile(file.path))
     };
 };
 export const savePackageRegistry = (rootDir, registry) => {
@@ -185,6 +279,16 @@ export const savePackageRegistry = (rootDir, registry) => {
 export const scanPackageRegistry = (rootDir) => {
     const srcRoot = getSrcRoot(rootDir);
     const sourceRoot = path.join(rootDir, srcRoot);
+    const existingRegistry = loadPackageRegistry(rootDir);
+    const existingFileState = new Map();
+    for (const record of Object.values(existingRegistry.packages)) {
+        for (const file of record.files) {
+            existingFileState.set(file.path, file);
+        }
+    }
+    for (const file of existingRegistry.files) {
+        existingFileState.set(file.path, file);
+    }
     const packages = [];
     const visit = (dir) => {
         if (!fs.existsSync(dir)) {
@@ -213,24 +317,31 @@ export const scanPackageRegistry = (rootDir) => {
     const allTsFiles = collectTsFiles(sourceRoot, rootDir);
     const ownedFiles = new Set();
     for (const file of allTsFiles) {
-        if (file === PACKAGE_REGISTRY_FILE || file.endsWith(".d.ts") || file.endsWith("index.ts")) {
+        if (file === PACKAGE_REGISTRY_FILE ||
+            file.endsWith(".d.ts") ||
+            file.endsWith("index.ts") ||
+            !isRegistryTrackableFile(file)) {
             continue;
         }
         const owner = [...packages]
             .filter((pkg) => fileBelongsToPackage(pkg.path, file))
             .sort((left, right) => right.path.length - left.path.length)[0];
-        const nextFile = {
-            type: inferFileType(file),
-            path: file
-        };
+        const existingFile = existingFileState.get(file);
+        const nextFile = createPackageFileRecord(inferFileType(file), file, owner ? existingFile?.registered ?? true : existingFile?.registered ?? false, existingFile?.tags ?? []);
         if (owner) {
-            owner.files.push(nextFile);
+            owner.files.push({
+                ...nextFile,
+                registered: existingFile?.registered ?? true
+            });
             ownedFiles.add(file);
         }
     }
     const unpackaged = [];
     for (const file of allTsFiles) {
-        if (file === PACKAGE_REGISTRY_FILE || file.endsWith(".d.ts") || file.endsWith("index.ts")) {
+        if (file === PACKAGE_REGISTRY_FILE ||
+            file.endsWith(".d.ts") ||
+            file.endsWith("index.ts") ||
+            !isRegistryTrackableFile(file)) {
             continue;
         }
         if (ownedFiles.has(file)) {
@@ -238,7 +349,9 @@ export const scanPackageRegistry = (rootDir) => {
         }
         unpackaged.push({
             type: inferFileType(file),
-            path: file
+            path: file,
+            registered: existingFileState.get(file)?.registered ?? false,
+            tags: existingFileState.get(file)?.tags ?? []
         });
     }
     return {
@@ -258,9 +371,9 @@ export const syncPackageRegistry = (rootDir) => {
     savePackageRegistry(rootDir, registry);
     return registry;
 };
-const derivePackageIndexView = (record) => {
-    const ownedFiles = record.files.filter((file) => file.path !== record.index);
-    const controllerFiles = ownedFiles.filter((file) => file.path.endsWith(".controller.ts"));
+const derivePackageIndexView = (record, style = "decorator") => {
+    const ownedFiles = record.files.filter((file) => file.path !== record.index && file.registered);
+    const controllerFiles = style === "decorator" ? ownedFiles.filter((file) => file.path.endsWith(".controller.ts")) : [];
     const serviceFiles = ownedFiles.filter((file) => file.path.endsWith(".service.ts"));
     const repositoryFiles = ownedFiles.filter((file) => file.path.endsWith(".repository.ts"));
     const middlewareFiles = ownedFiles.filter((file) => file.path.endsWith(".middleware.ts"));
@@ -268,29 +381,28 @@ const derivePackageIndexView = (record) => {
     const routeHandlerFiles = ownedFiles.filter((file) => file.path.endsWith(".route.handler.ts"));
     const dtoFiles = ownedFiles.filter((file) => file.path.endsWith(".dto.ts"));
     const typeFiles = ownedFiles.filter((file) => file.path.endsWith(".types.ts") || file.path.endsWith(".type.ts"));
-    const importableFiles = [
-        ...controllerFiles,
-        ...serviceFiles,
-        ...repositoryFiles,
-        ...middlewareFiles,
-        ...routeFiles,
-        ...dtoFiles
-    ];
-    const exportFiles = [
-        ...controllerFiles,
-        ...serviceFiles,
-        ...repositoryFiles,
-        ...middlewareFiles,
-        ...routeFiles,
-        ...routeHandlerFiles,
-        ...dtoFiles
-    ];
-    const packageExportFiles = [
-        ...serviceFiles,
-        ...repositoryFiles,
-        ...middlewareFiles,
-        ...dtoFiles
-    ];
+    const importableFiles = style === "functional"
+        ? [...routeFiles]
+        : [
+            ...controllerFiles,
+            ...serviceFiles,
+            ...repositoryFiles,
+            ...middlewareFiles,
+            ...routeFiles,
+            ...dtoFiles
+        ];
+    const exportFiles = style === "functional"
+        ? [...serviceFiles, ...repositoryFiles, ...routeFiles, ...routeHandlerFiles, ...typeFiles]
+        : [
+            ...controllerFiles,
+            ...serviceFiles,
+            ...repositoryFiles,
+            ...middlewareFiles,
+            ...routeFiles,
+            ...routeHandlerFiles,
+            ...dtoFiles
+        ];
+    const packageExportFiles = style === "functional" ? [] : [...serviceFiles, ...repositoryFiles, ...middlewareFiles, ...dtoFiles];
     const renderArray = (values) => values.length === 0 ? "[]" : `[\n${values.map((value) => `    ${value}`).join(",\n")}\n  ]`;
     const imports = importableFiles
         .map((file) => {
@@ -308,7 +420,21 @@ const derivePackageIndexView = (record) => {
         return `export * from "./${relative}";`;
     })
         .join("\n");
-    const packageBlock = `@Package({
+    const packageBlock = style === "functional"
+        ? `const ${toPascalCase(record.name)}PackageDefinition = {
+  name: "${record.name}",
+  path: "${record.path}",
+  imports: [],
+  exports: [],
+  controllers: [],
+  services: [],
+  repositories: [],
+  middlewares: [],
+  routes: ${renderArray(routeFiles.map((file) => inferSymbolFromFile(file.path)))}
+};
+
+export const ${toPascalCase(record.name)}Package = Package(${toPascalCase(record.name)}PackageDefinition)(() => ${toPascalCase(record.name)}PackageDefinition);`
+        : `@Package({
   name: "${record.name}",
   path: "${record.path}",
   imports: [],
@@ -322,9 +448,12 @@ const derivePackageIndexView = (record) => {
 export class ${toPascalCase(record.name)}Package {}`;
     return { imports, exports, packageBlock };
 };
-export const renderPackageIndex = (record) => {
-    const sections = derivePackageIndexView(record);
-    return `/**\n * @generated true\n */\nimport { Package } from "@sculptor/core";\n\n// [sculptor:imports:start]\n${sections.imports}\n// [sculptor:imports:end]\n\n// [sculptor:exports:start]\n${sections.exports}\n// [sculptor:exports:end]\n\n// [sculptor:package:start]\n${sections.packageBlock}\n// [sculptor:package:end]\n`;
+export const renderPackageIndex = (record, style = "decorator") => {
+    const sections = derivePackageIndexView(record, style);
+    const importLine = style === "functional"
+        ? 'import { Package, type SculptorFunctionalPackage } from "@sculptor/core";'
+        : 'import { Package } from "@sculptor/core";';
+    return `/**\n * @generated true\n */\n${importLine}\n\n// [sculptor:imports:start]\n${sections.imports}\n// [sculptor:imports:end]\n\n// [sculptor:exports:start]\n${sections.exports}\n// [sculptor:exports:end]\n\n// [sculptor:package:start]\n${sections.packageBlock}\n// [sculptor:package:end]\n`;
 };
 export const inferPackageNameFromPath = (packagePath) => normalizeRelativePath(path.posix.basename(packagePath));
 export const inferPackagePath = (rootDir, packageName, explicitPath) => {
@@ -333,7 +462,7 @@ export const inferPackagePath = (rootDir, packageName, explicitPath) => {
     if (explicitPath) {
         return normalizeRelativePath(path.posix.join(normalizeRelativePath(explicitPath), packageFolder));
     }
-    return normalizeRelativePath(path.posix.join(srcRoot, packageFolder));
+    return normalizeRelativePath(path.posix.join(srcRoot, "app", packageFolder));
 };
 export const inferPackageIndexPath = (packagePath) => normalizeRelativePath(path.posix.join(packagePath, "index.ts"));
 export const buildPackageRecord = (rootDir, packageName, explicitPath) => {
@@ -341,11 +470,11 @@ export const buildPackageRecord = (rootDir, packageName, explicitPath) => {
     const index = inferPackageIndexPath(packagePath);
     const normalizedPackageName = normalizeRelativePath(packageName);
     const files = [
-        { type: "controller", path: normalizeRelativePath(path.posix.join(packagePath, `${normalizedPackageName}.controller.ts`)) },
-        { type: "service", path: normalizeRelativePath(path.posix.join(packagePath, `${normalizedPackageName}.service.ts`)) },
-        { type: "repository", path: normalizeRelativePath(path.posix.join(packagePath, `${normalizedPackageName}.repository.ts`)) },
-        { type: "dto", path: normalizeRelativePath(path.posix.join(packagePath, `${normalizedPackageName}.dto.ts`)) },
-        { type: "type", path: normalizeRelativePath(path.posix.join(packagePath, `${normalizedPackageName}.types.ts`)) }
+        createPackageFileRecord("controller", path.posix.join(packagePath, `${normalizedPackageName}.controller.ts`), true),
+        createPackageFileRecord("service", path.posix.join(packagePath, `${normalizedPackageName}.service.ts`), true),
+        createPackageFileRecord("repository", path.posix.join(packagePath, `${normalizedPackageName}.repository.ts`), true),
+        createPackageFileRecord("dto", path.posix.join(packagePath, `${normalizedPackageName}.dto.ts`), true),
+        createPackageFileRecord("type", path.posix.join(packagePath, `${normalizedPackageName}.types.ts`), true)
     ];
     return {
         name: normalizedPackageName,
@@ -368,52 +497,67 @@ const renderPackageRegistryImport = (srcRoot, record) => {
         : record.path;
     return `import { ${toPascalCase(record.name)}Package } from "./${normalizeRelativePath(path.posix.join(packageImportPath, "index.js"))}";`;
 };
-const renderRegistryRootFile = (srcRoot, records) => {
-    const imports = records.map((record) => renderPackageRegistryImport(srcRoot, record)).join("\n");
-    const packageEntries = records.map((record) => `${toPascalCase(record.name)}Package`).join(", ");
-    return `${imports}${imports ? "\n\n" : ""}export const registry = {\n  packages: [${packageEntries}],\n  controllers: [],\n  routes: [],\n  services: [],\n  repositories: [],\n  middlewares: []\n};\n`;
+const renderDirectRegistryImport = (srcRoot, file) => {
+    if (!["controller", "service", "repository", "middleware", "route"].includes(file.type)) {
+        return undefined;
+    }
+    const sourcePath = file.path.startsWith(`${srcRoot}/`)
+        ? file.path.slice(`${srcRoot}/`.length)
+        : file.path;
+    const symbol = inferSymbolFromFile(file.path);
+    return `import { ${symbol} } from "./${normalizeRelativePath(path.posix.join(sourcePath.replace(/\.ts$/, ".js")))}";`;
+};
+const renderRegistryRootFile = (rootDir, registry) => {
+    const srcRoot = getSrcRoot(rootDir);
+    const packageRecords = Object.values(registry.packages).sort((left, right) => left.name.localeCompare(right.name));
+    const directFiles = registry.files
+        .filter((file) => file.registered)
+        .sort((left, right) => left.path.localeCompare(right.path));
+    const packageImports = packageRecords.map((record) => renderPackageRegistryImport(srcRoot, record));
+    const directImports = directFiles
+        .map((file) => renderDirectRegistryImport(srcRoot, file))
+        .filter((value) => Boolean(value));
+    const directControllers = directFiles
+        .filter((file) => file.type === "controller")
+        .map((file) => inferSymbolFromFile(file.path));
+    const directServices = directFiles
+        .filter((file) => file.type === "service")
+        .map((file) => inferSymbolFromFile(file.path));
+    const directRepositories = directFiles
+        .filter((file) => file.type === "repository")
+        .map((file) => inferSymbolFromFile(file.path));
+    const directMiddlewares = directFiles
+        .filter((file) => file.type === "middleware")
+        .map((file) => inferSymbolFromFile(file.path));
+    const directRoutes = directFiles
+        .filter((file) => file.type === "route")
+        .map((file) => inferSymbolFromFile(file.path));
+    const packageEntries = packageRecords.map((record) => `${toPascalCase(record.name)}Package`);
+    return `/**
+ * @generated true
+ */
+${[...packageImports, ...directImports].join("\n")}
+
+export const registry = {
+  packages: [${packageEntries.join(", ")}],
+  controllers: [${directControllers.join(", ")}],
+  routes: [${directRoutes.join(", ")}],
+  services: [${directServices.join(", ")}],
+  repositories: [${directRepositories.join(", ")}],
+  middlewares: [${directMiddlewares.join(", ")}]
+};
+`;
 };
 export const syncRootRegistryForPackages = (rootDir) => {
     const srcRoot = getSrcRoot(rootDir);
     const registryPath = path.join(rootDir, srcRoot, "registry.ts");
     const registry = loadPackageRegistry(rootDir);
-    const packageRecords = Object.values(registry.packages).sort((left, right) => left.name.localeCompare(right.name));
-    if (packageRecords.length === 0 && !fs.existsSync(registryPath)) {
+    if (Object.keys(registry.packages).length === 0 && registry.files.length === 0 && !fs.existsSync(registryPath)) {
         return registryPath;
     }
     fs.mkdirSync(path.dirname(registryPath), { recursive: true });
-    if (!fs.existsSync(registryPath)) {
-        const next = renderRegistryRootFile(srcRoot, packageRecords);
-        fs.writeFileSync(registryPath, next, "utf8");
-        return registryPath;
-    }
-    const current = fs.readFileSync(registryPath, "utf8");
-    const packageImportPattern = /^import \{ [^}]+Package \} from "\.\/.*\/index\.js";\n?/gm;
-    const hasPackageRegistryShape = packageImportPattern.test(current) || /packages:\s*\[[^\]]*\]/m.test(current);
-    packageImportPattern.lastIndex = 0;
-    if (packageRecords.length === 0 && !hasPackageRegistryShape) {
-        return registryPath;
-    }
-    const imports = packageRecords.map((record) => renderPackageRegistryImport(srcRoot, record)).join("\n");
-    const packageEntries = packageRecords.map((record) => `${toPascalCase(record.name)}Package`).join(", ");
-    const strippedImports = current.replace(packageImportPattern, "");
-    const withImports = `${imports}${imports ? "\n\n" : ""}${strippedImports}`.replace(/^\n+/, "");
-    const packagePattern = /packages:\s*\[[^\]]*\]/m;
-    if (packagePattern.test(withImports)) {
-        const next = withImports.replace(packagePattern, `packages: [${packageEntries}]`);
-        if (next !== current) {
-            fs.writeFileSync(registryPath, next, "utf8");
-        }
-        return registryPath;
-    }
-    const registryOpenPattern = /(export const registry = \{\n)/;
-    if (!registryOpenPattern.test(withImports)) {
-        throw new Error(`Unable to update ${registryPath} safely. registry.ts is malformed.`);
-    }
-    const next = withImports.replace(registryOpenPattern, `$1  packages: [${packageEntries}],\n`);
-    if (next !== current) {
-        fs.writeFileSync(registryPath, next, "utf8");
-    }
+    const next = renderRegistryRootFile(rootDir, registry);
+    fs.writeFileSync(registryPath, next, "utf8");
     return registryPath;
 };
 export const upsertFileIntoRegistry = (registry, filePath) => {
@@ -427,10 +571,7 @@ export const upsertFileIntoRegistry = (registry, filePath) => {
             continue;
         }
         const existingIndex = record.files.findIndex((entry) => entry.path === normalizedPath);
-        const nextFile = {
-            type: fileType,
-            path: normalizedPath
-        };
+        const nextFile = createPackageFileRecord(fileType, normalizedPath, true);
         if (existingIndex >= 0) {
             record.files[existingIndex] = nextFile;
         }
@@ -440,10 +581,7 @@ export const upsertFileIntoRegistry = (registry, filePath) => {
         return registry;
     }
     const existing = registry.files.findIndex((entry) => entry.path === normalizedPath);
-    const nextFile = {
-        type: fileType,
-        path: normalizedPath
-    };
+    const nextFile = createPackageFileRecord(fileType, normalizedPath, true);
     if (existing >= 0) {
         registry.files[existing] = nextFile;
     }
@@ -452,7 +590,39 @@ export const upsertFileIntoRegistry = (registry, filePath) => {
     }
     return registry;
 };
-export const removeFileFromRegistry = (registry, filePath) => {
+export const unregisterFileFromRegistry = (registry, filePath) => {
+    const normalizedPath = normalizeRelativePath(filePath);
+    for (const record of Object.values(registry.packages)) {
+        if (normalizedPath === record.index) {
+            return registry;
+        }
+        if (!isFileOwnedByPackage(record, normalizedPath)) {
+            continue;
+        }
+        const existingIndex = record.files.findIndex((entry) => entry.path === normalizedPath);
+        if (existingIndex >= 0) {
+            record.files[existingIndex] = {
+                ...record.files[existingIndex],
+                registered: false
+            };
+        }
+        else {
+            record.files.push(createPackageFileRecord(inferFileType(normalizedPath), normalizedPath, false));
+        }
+        return registry;
+    }
+    const existingIndex = registry.files.findIndex((entry) => entry.path === normalizedPath);
+    if (existingIndex >= 0) {
+        registry.files[existingIndex] = {
+            ...registry.files[existingIndex],
+            registered: false
+        };
+        return registry;
+    }
+    registry.files.push(createPackageFileRecord(inferFileType(normalizedPath), normalizedPath, false));
+    return registry;
+};
+export const deleteFileFromRegistry = (registry, filePath) => {
     const normalizedPath = normalizeRelativePath(filePath);
     for (const record of Object.values(registry.packages)) {
         if (normalizedPath === record.index) {
@@ -471,7 +641,7 @@ export const getOwningPackage = (registry, filePath) => {
     const normalizedPath = normalizeRelativePath(filePath);
     return Object.values(registry.packages).find((record) => isFileOwnedByPackage(record, normalizedPath));
 };
-export const renderPackageIndexForRecord = (record) => renderPackageIndex(record);
+export const renderPackageIndexForRecord = (record) => renderPackageIndex(record, inferPackageIndexStyle(record));
 const generatedMarkers = {
     imports: {
         start: "// [sculptor:imports:start]",
@@ -498,8 +668,17 @@ const replaceMarkerBlock = (source, section, content) => {
     }
     return `${source.slice(0, startIndex + start.length)}\n${content}\n${source.slice(endIndex)}`;
 };
-const renderPackageIndexSections = (record) => {
-    const sections = derivePackageIndexView(record);
+const inferPackageIndexStyle = (record, sourceText) => {
+    if (sourceText?.includes("SculptorFunctionalPackage")) {
+        return "functional";
+    }
+    if (record.files.some((file) => file.path.endsWith(".controller.ts"))) {
+        return "decorator";
+    }
+    return "functional";
+};
+const renderPackageIndexSections = (record, style = "decorator") => {
+    const sections = derivePackageIndexView(record, style);
     return {
         imports: sections.imports,
         exports: sections.exports,
@@ -507,20 +686,20 @@ const renderPackageIndexSections = (record) => {
     };
 };
 export const updatePackageIndexForRecord = (filePath, record) => {
-    const next = renderPackageIndex(record);
     if (!fs.existsSync(filePath)) {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, next, "utf8");
+        fs.writeFileSync(filePath, renderPackageIndex(record, inferPackageIndexStyle(record)), "utf8");
         return;
     }
     const current = fs.readFileSync(filePath, "utf8");
+    const style = inferPackageIndexStyle(record, current);
     for (const section of Object.keys(generatedMarkers)) {
         if (!current.includes(generatedMarkers[section].start) || !current.includes(generatedMarkers[section].end)) {
             throw new Error(`Package index markers are missing or malformed in ${filePath}. Refusing to rewrite the file unsafely.`);
         }
     }
     let updated = current;
-    const sections = renderPackageIndexSections(record);
+    const sections = renderPackageIndexSections(record, style);
     updated = replaceMarkerBlock(updated, "imports", sections.imports);
     updated = replaceMarkerBlock(updated, "exports", sections.exports);
     updated = replaceMarkerBlock(updated, "package", sections.package);