feature (patch): static patches

server/common/plugin.go

@@ -244,13 +244,13 @@ func (this Get) Middleware() []func(HandlerFunc) HandlerFunc {
 	return middlewares
 }
 
-var staticOverrides []fs.FS
+var staticOverrides [][]byte
 
-func (this Register) StaticPatch(folder fs.FS) {
+func (this Register) StaticPatch(pathFile []byte) {
-	staticOverrides = append(staticOverrides, folder)
+	staticOverrides = append(staticOverrides, pathFile)
 }
 
-func (this Get) StaticPatch() []fs.FS {
+func (this Get) StaticPatch() [][]byte {
 	return staticOverrides
 }
 

server/ctrl/static.go

@@ -275,48 +275,49 @@ func ServeBundle(ctx *App, res http.ResponseWriter, req *http.Request) {
 }
 
 func applyPatch(filePath string) (file *bytes.Buffer) {
-	origFile, err := WWWPublic.Open(filePath)
-	if err != nil {
-		Log.Debug("ctrl::static cannot open public file - %+v", err.Error())
-		return nil
-	}
 	var (
 		outputBuffer bytes.Buffer
-		outputInit   bool
+		wasPatched   bool
 	)
-	defer origFile.Close()
+	for i, patch := range Hooks.Get.StaticPatch() {
-	for _, patch := range Hooks.Get.StaticPatch() {
+		if i == 0 {
-		patchFile, err := patch.Open(strings.TrimPrefix(filePath, "/"))
+			origFile, err := WWWPublic.Open(filePath)
-		if err != nil {
+			if err != nil {
-			continue
+				Log.Debug("ctrl::static cannot open public file - %+v", err.Error())
-		}
+				return nil
-		patchFiles, _, err := gitdiff.Parse(patchFile)
+			}
-		patchFile.Close()
+			_, err = outputBuffer.ReadFrom(origFile)
-		if err != nil {
+			origFile.Close()
-			Log.Debug("ctrl::static cannot parse patch file - %s", err.Error())
+			if err != nil {
-			break
+				Log.Debug("ctrl::static cannot read from origFile - %s", err.Error())
-		} else if len(patchFiles) != 1 {
-			Log.Debug("ctrl::static unepected patch file size - must be 1, got %d", len(patchFiles))
-			break
-		}
-		if !outputInit {
-			if _, err = outputBuffer.ReadFrom(origFile); err != nil {
 				return nil
 			}
-			outputInit = true
 		}
-		var patched bytes.Buffer
+		patchFiles, _, err := gitdiff.Parse(NewReadCloserFromBytes(patch))
-		if err := gitdiff.Apply(
+		if err != nil {
-			&patched,
+			Log.Debug("ctrl::static cannot parse patch file - %s", err.Error())
-			bytes.NewReader(outputBuffer.Bytes()),
-			patchFiles[0],
-		); err != nil {
-			Log.Debug("ctrl::static cannot apply patch - %s", err.Error())
 			return nil
 		}
-		outputBuffer = patched
+		for i := 0; i < len(patchFiles); i++ {
+			if patchFiles[i].NewName != patchFiles[i].OldName {
+				continue
+			} else if filePath != strings.TrimPrefix(patchFiles[i].NewName, "public") {
+				continue
+			}
+			var patched bytes.Buffer
+			if err := gitdiff.Apply(
+				&patched,
+				bytes.NewReader(outputBuffer.Bytes()),
+				patchFiles[i],
+			); err != nil {
+				Log.Debug("ctrl::static cannot apply patch - %s", err.Error())
+				return nil
+			}
+			outputBuffer = patched
+			wasPatched = true
+		}
 	}
-	if outputInit {
+	if wasPatched {
 		return &outputBuffer
 	}
 	return nil

server/model/plugin.go

@@ -35,12 +35,36 @@ func PluginDiscovery() error {
 		if strings.HasSuffix(fname, ".zip") == false {
 			continue
 		}
-		name, modules, err := InitModule(entry.Name())
+		name, impl, err := InitModule(entry.Name())
 		if err != nil {
 			Log.Error("could not initialise module name=%s err=%s", entry.Name(), err.Error())
 			continue
 		}
-		PLUGINS[name] = modules
+		for i := 0; i < len(impl.Modules); i++ {
+			switch impl.Modules[i]["type"] {
+			case "css":
+				f, err := GetPluginFile(name, impl.Modules[i]["entrypoint"])
+				if err != nil {
+					return err
+				}
+				b, err := io.ReadAll(f)
+				if err != nil {
+					return err
+				}
+				Hooks.Register.CSS(string(b))
+			case "patch":
+				f, err := GetPluginFile(name, impl.Modules[i]["entrypoint"])
+				if err != nil {
+					return err
+				}
+				b, err := io.ReadAll(f)
+				if err != nil {
+					return err
+				}
+				Hooks.Register.StaticPatch(b)
+			}
+		}
+		PLUGINS[name] = impl
 	}
 	return nil
 }