@valbuild/core 0.21.2 → 0.23.0

package/src/patch/deref.ts

@@ -38,7 +38,6 @@ function derefPath(
 export type DerefPatchResult = {
   dereferencedPatch: Patch;
   fileUpdates: { [path: string]: string };
-  remotePatches: { [ref: string]: Patch };
 };
 
 export function derefPatch<D, E>(
@@ -46,9 +45,6 @@ export function derefPatch<D, E>(
   document: D,
   ops: Ops<D, E>
 ): result.Result<DerefPatchResult, E | PatchError> {
-  const remotePatches: {
-    [ref: string]: Patch;
-  } = {};
   const fileUpdates: {
     [file: string]: string;
   } = {};
@@ -84,15 +80,15 @@ export function derefPatch<D, E>(
               );
             }
             fileUpdates[value[FILE_REF_PROP]] = op.value;
-          } else if (isRemote(value)) {
-            if (!remotePatches[value[REMOTE_REF_PROP]]) {
-              remotePatches[value[REMOTE_REF_PROP]] = [];
-            }
-            remotePatches[value[REMOTE_REF_PROP]].push({
-              op: "replace",
-              path: referencedPath,
-              value: op.value,
-            });
+            // } else if (isRemote(value)) {
+            //   if (!remotePatches[value[REMOTE_REF_PROP]]) {
+            //     remotePatches[value[REMOTE_REF_PROP]] = [];
+            //   }
+            //   remotePatches[value[REMOTE_REF_PROP]].push({
+            //     op: "replace",
+            //     path: referencedPath,
+            //     value: op.value,
+            //   });
           } else {
             return result.err(
               new PatchError(
@@ -109,8 +105,8 @@ export function derefPatch<D, E>(
         dereferencedPatch.push(op);
       }
     } else if (op.op === "file") {
-      if (op.path[0] !== "public") {
-        return result.err(new PatchError(`Path must start with public`));
+      if (!op.filePath.startsWith("/public")) {
+        return result.err(new PatchError(`Path must start with /public`));
       }
       if (typeof op.value !== "string") {
         return result.err(
@@ -119,7 +115,7 @@ export function derefPatch<D, E>(
           )
         );
       }
-      fileUpdates[`/${op.path.join("/")}`] = op.value;
+      fileUpdates[op.filePath] = op.value;
     } else {
       const maybeDerefRes = derefPath(op.path);
       if (result.isErr(maybeDerefRes)) {
@@ -134,7 +130,6 @@ export function derefPatch<D, E>(
   }
 
   return result.ok({
-    remotePatches,
     fileUpdates,
     dereferencedPatch,
   });

package/src/patch/operation.ts

@@ -37,6 +37,7 @@ export type OperationJSON =
   | {
       op: "file";
       path: string;
+      filePath: string;
       value: JSONValue;
     };
 
@@ -80,5 +81,6 @@ export type Operation =
   | {
       op: "file";
       path: string[];
+      filePath: string;
       value: JSONValue;
     };

package/src/patch/parse.ts

@@ -95,7 +95,6 @@ export function parseOperation(
   const path = parseJSONPointer(operation.path);
 
   switch (operation.op) {
-    case "file":
     case "add":
     case "replace":
     case "test":
@@ -112,6 +111,21 @@ export function parseOperation(
           value: operation.value,
         }))
       );
+    case "file":
+      return pipe(
+        path,
+        result.mapErr(
+          (error: string): array.NonEmptyArray<StaticPatchIssue> => [
+            createIssueAtPath(["path"])(error),
+          ]
+        ),
+        result.map((path: string[]) => ({
+          op: operation.op,
+          path,
+          filePath: operation.filePath,
+          value: operation.value,
+        }))
+      );
     case "remove":
       return pipe(
         path,

package/src/schema/image.ts

@@ -122,10 +122,12 @@ export const convertFileSource = (
 ): { url: string; metadata?: ImageMetadata } => {
   // TODO: /public should be configurable
   if (!src[FILE_REF_PROP].startsWith("/public")) {
-    throw Error(
-      `Invalid reference: ${src[FILE_REF_PROP]}. Did not start with /public`
-    );
+    return {
+      url: src[FILE_REF_PROP] + `?sha256=${src.metadata?.sha256}`,
+      metadata: src.metadata,
+    };
   }
+
   return {
     url:
       src[FILE_REF_PROP].slice("/public".length) +

package/src/schema/string.ts

@@ -15,6 +15,9 @@ export type SerializedStringSchema = {
   raw: boolean;
 };
 
+const brand = Symbol("string");
+export type RawString = string & { readonly [brand]: "raw" };
+
 export class StringSchema<Src extends string | null> extends Schema<Src> {
   constructor(
     readonly options?: StringOptions,
@@ -35,6 +38,24 @@ export class StringSchema<Src extends string | null> extends Schema<Src> {
         ],
       } as ValidationErrors;
     }
+    const errors = [];
+    if (this.options?.maxLength && src.length > this.options.maxLength) {
+      errors.push({
+        message: `Expected string to be at most ${this.options.maxLength} characters long, got ${src.length}`,
+        value: src,
+      });
+    }
+    if (this.options?.minLength && src.length < this.options.minLength) {
+      errors.push({
+        message: `Expected string to be at least ${this.options.minLength} characters long, got ${src.length}`,
+        value: src,
+      });
+    }
+    if (errors.length > 0) {
+      return {
+        [path]: errors,
+      } as ValidationErrors;
+    }
     return false;
   }
 
@@ -49,8 +70,12 @@ export class StringSchema<Src extends string | null> extends Schema<Src> {
     return new StringSchema<Src | null>(this.options, true, this.isRaw);
   }
 
-  raw(): StringSchema<Src> {
-    return new StringSchema<Src>(this.options, this.opt, true);
+  raw(): StringSchema<Src extends null ? RawString | null : RawString> {
+    return new StringSchema<Src extends null ? RawString | null : RawString>(
+      this.options,
+      this.opt,
+      true
+    );
   }
 
   serialize(): SerializedSchema {