Run an optional "postinit" command in a template directory

Author: pkosiec

cmd/apps/init.go

@@ -792,14 +792,6 @@ func runCreate(ctx context.Context, opts createOptions) error {
 		absOutputDir = destDir
 	}
 
-	// Apply plugin-specific post-processing (e.g., remove config/queries if analytics not selected)
-	runErr = prompt.RunWithSpinnerCtx(ctx, "Configuring plugins...", func() error {
-		return applyPlugins(absOutputDir, selectedPlugins, m.GetTemplatePaths())
-	})
-	if runErr != nil {
-		return runErr
-	}
-
 	// Initialize project based on type (Node.js, Python, etc.)
 	var nextStepsCmd string
 	projectInitializer := initializer.GetProjectInitializer(absOutputDir)
@@ -946,28 +938,6 @@ func buildPluginStrings(pluginNames []string) (pluginImport, pluginUsage string)
 	return pluginImport, pluginUsage
 }
 
-// applyPlugins removes template directories owned by unselected plugins.
-func applyPlugins(projectDir string, pluginNames []string, templatePaths map[string][]string) error {
-	selectedSet := make(map[string]bool)
-	for _, name := range pluginNames {
-		selectedSet[name] = true
-	}
-
-	for plugin, paths := range templatePaths {
-		if selectedSet[plugin] {
-			continue
-		}
-		for _, p := range paths {
-			target := filepath.Join(projectDir, p)
-			if err := os.RemoveAll(target); err != nil && !os.IsNotExist(err) {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
 // renameFiles maps source file names to destination names (for files that can't use special chars).
 var renameFiles = map[string]string{
 	"_gitignore":  ".gitignore",

cmd/apps/init_test.go

@@ -458,59 +458,6 @@ func TestAppendUniqueNoValues(t *testing.T) {
 	assert.Equal(t, []string{"a", "b"}, result)
 }
 
-func TestApplyPlugins(t *testing.T) {
-	tests := []struct {
-		name          string
-		selected      []string
-		templatePaths map[string][]string
-		expectRemoved []string
-		expectKept    []string
-	}{
-		{
-			name:          "unselected plugin directory is removed",
-			selected:      []string{"server"},
-			templatePaths: map[string][]string{"analytics": {"config/queries"}},
-			expectRemoved: []string{"config/queries"},
-		},
-		{
-			name:          "selected plugin directory is kept",
-			selected:      []string{"analytics", "server"},
-			templatePaths: map[string][]string{"analytics": {"config/queries"}},
-			expectKept:    []string{"config/queries"},
-		},
-		{
-			name:          "empty templatePaths is a no-op",
-			selected:      []string{"server"},
-			templatePaths: map[string][]string{},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			dir := t.TempDir()
-
-			// Create all directories referenced in templatePaths
-			for _, paths := range tc.templatePaths {
-				for _, p := range paths {
-					require.NoError(t, os.MkdirAll(filepath.Join(dir, p), 0o755))
-				}
-			}
-
-			err := applyPlugins(dir, tc.selected, tc.templatePaths)
-			require.NoError(t, err)
-
-			for _, p := range tc.expectRemoved {
-				_, statErr := os.Stat(filepath.Join(dir, p))
-				assert.True(t, os.IsNotExist(statErr), "expected %s to be removed", p)
-			}
-			for _, p := range tc.expectKept {
-				_, statErr := os.Stat(filepath.Join(dir, p))
-				assert.NoError(t, statErr, "expected %s to exist", p)
-			}
-		})
-	}
-}
-
 func TestRunManifestOnlyFound(t *testing.T) {
 	dir := t.TempDir()
 	manifestPath := filepath.Join(dir, manifest.ManifestFileName)

libs/apps/initializer/nodejs.go

@@ -40,6 +40,9 @@ func (i *InitializerNodeJs) Initialize(ctx context.Context, workDir string) *Ini
 		}
 	}
 
+	// Step 3: Run postinit script if defined (fully optional — errors are logged, not fatal)
+	i.runNpmPostInit(ctx, workDir)
+
 	return &InitResult{
 		Success: true,
 		Message: "Node.js project initialized successfully",
@@ -102,6 +105,43 @@ func (i *InitializerNodeJs) runAppkitSetup(ctx context.Context, workDir string)
 	})
 }
 
+// runNpmPostInit runs "npm run postinit" if the script is defined in package.json.
+// Failures are logged as warnings and never propagate — postinit is fully optional.
+func (i *InitializerNodeJs) runNpmPostInit(ctx context.Context, workDir string) {
+	if !i.hasNpmScript(workDir, "postinit") {
+		return
+	}
+	err := prompt.RunWithSpinnerCtx(ctx, "Running post-init...", func() error {
+		cmd := exec.CommandContext(ctx, "npm", "run", "postinit")
+		cmd.Dir = workDir
+		cmd.Stdout = nil
+		cmd.Stderr = nil
+		return cmd.Run()
+	})
+	if err != nil {
+		log.Debugf(ctx, "postinit script failed (non-fatal): %v", err)
+	}
+}
+
+// hasNpmScript reports whether the given script name is defined in the project's package.json.
+func (i *InitializerNodeJs) hasNpmScript(workDir, script string) bool {
+	packageJSONPath := filepath.Join(workDir, "package.json")
+	data, err := os.ReadFile(packageJSONPath)
+	if err != nil {
+		return false
+	}
+
+	var pkg struct {
+		Scripts map[string]string `json:"scripts"`
+	}
+	if err := json.Unmarshal(data, &pkg); err != nil {
+		return false
+	}
+
+	_, ok := pkg.Scripts[script]
+	return ok
+}
+
 // hasAppkit checks if the project has @databricks/appkit in its dependencies.
 func (i *InitializerNodeJs) hasAppkit(workDir string) bool {
 	packageJSONPath := filepath.Join(workDir, "package.json")

libs/apps/initializer/nodejs_test.go

@@ -65,3 +65,60 @@ func TestHasAppkitNoPackageJSON(t *testing.T) {
 	init := &InitializerNodeJs{}
 	assert.False(t, init.hasAppkit(tmpDir))
 }
+
+func TestHasNpmScript(t *testing.T) {
+	tests := []struct {
+		name        string
+		packageJSON string
+		script      string
+		want        bool
+	}{
+		{
+			name:        "script present",
+			packageJSON: `{"scripts": {"postinit": "appkit postinit"}}`,
+			script:      "postinit",
+			want:        true,
+		},
+		{
+			name:        "script absent",
+			packageJSON: `{"scripts": {"build": "tsc"}}`,
+			script:      "postinit",
+			want:        false,
+		},
+		{
+			name:        "no scripts section",
+			packageJSON: `{}`,
+			script:      "postinit",
+			want:        false,
+		},
+		{
+			name:        "invalid json",
+			packageJSON: `not json`,
+			script:      "postinit",
+			want:        false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tmpDir, err := os.MkdirTemp("", "nodejs-test-*")
+			require.NoError(t, err)
+			defer os.RemoveAll(tmpDir)
+
+			err = os.WriteFile(filepath.Join(tmpDir, "package.json"), []byte(tt.packageJSON), 0o644)
+			require.NoError(t, err)
+
+			i := &InitializerNodeJs{}
+			assert.Equal(t, tt.want, i.hasNpmScript(tmpDir, tt.script))
+		})
+	}
+}
+
+func TestHasNpmScriptNoPackageJSON(t *testing.T) {
+	tmpDir, err := os.MkdirTemp("", "nodejs-test-*")
+	require.NoError(t, err)
+	defer os.RemoveAll(tmpDir)
+
+	i := &InitializerNodeJs{}
+	assert.False(t, i.hasNpmScript(tmpDir, "postinit"))
+}

libs/apps/manifest/manifest.go

@@ -67,7 +67,6 @@ type Plugin struct {
 	Description        string    `json:"description"`
 	Package            string    `json:"package"`
 	RequiredByTemplate bool      `json:"requiredByTemplate"`
-	TemplatePaths      []string  `json:"templatePaths,omitempty"`
 	Resources          Resources `json:"resources"`
 }
 
@@ -206,18 +205,6 @@ func (m *Manifest) CollectResources(pluginNames []string) []Resource {
 	return resources
 }
 
-// GetTemplatePaths returns a map of plugin name to template directory paths.
-// Only plugins that declare at least one path are included.
-func (m *Manifest) GetTemplatePaths() map[string][]string {
-	result := make(map[string][]string)
-	for name, p := range m.Plugins {
-		if len(p.TemplatePaths) > 0 {
-			result[name] = p.TemplatePaths
-		}
-	}
-	return result
-}
-
 // CollectOptionalResources returns all optional resources for the given plugin names.
 func (m *Manifest) CollectOptionalResources(pluginNames []string) []Resource {
 	seen := make(map[string]bool)

libs/apps/manifest/manifest_test.go

@@ -320,34 +320,6 @@ func TestResourceKey(t *testing.T) {
 	assert.Equal(t, "sql_warehouse", r.VarPrefix())
 }
 
-func TestGetTemplatePaths(t *testing.T) {
-	m := &manifest.Manifest{
-		Plugins: map[string]manifest.Plugin{
-			"analytics": {
-				Name:          "analytics",
-				TemplatePaths: []string{"config/queries"},
-			},
-			"server": {
-				Name: "server",
-			},
-		},
-	}
-
-	paths := m.GetTemplatePaths()
-	assert.Equal(t, map[string][]string{"analytics": {"config/queries"}}, paths)
-}
-
-func TestGetTemplatePathsEmpty(t *testing.T) {
-	m := &manifest.Manifest{
-		Plugins: map[string]manifest.Plugin{
-			"server": {Name: "server"},
-		},
-	}
-
-	paths := m.GetTemplatePaths()
-	assert.Empty(t, paths)
-}
-
 func TestCollectOptionalResources(t *testing.T) {
 	m := &manifest.Manifest{
 		Plugins: map[string]manifest.Plugin{