- tightened tights even further + related fixes

- tightened deepCopy and mergeObjects

Author: seefeldb

packages/builder/src/types.ts

@@ -177,8 +177,7 @@ export type StreamAlias = {
 };
 
 export function isStreamAlias(value: unknown): value is StreamAlias {
-  return !!value && typeof (value as StreamAlias).$stream === "boolean" &&
-    (value as StreamAlias).$stream;
+  return isObject(value) && "$stream" in value && value.$stream === true;
 }
 
 export type Module = {
@@ -196,7 +195,7 @@ export type Handler<T = any, R = any> = Module & {
 export function isModule(value: unknown): value is Module {
   return (
     (typeof value === "function" || typeof value === "object") &&
-    typeof (value as any).type === "string"
+    value !== null && typeof (value as unknown as Module).type === "string"
   );
 }
 

packages/deno-vite-plugin/src/prefixPlugin.ts

@@ -1,4 +1,4 @@
-import { Plugin } from "vite";
+import { type Plugin, type ResolvedConfig } from "vite";
 import {
   DenoResolveResult,
   resolveDeno,
@@ -14,10 +14,10 @@ export default function denoPrefixPlugin(
   return {
     name: "deno:prefix",
     enforce: "pre",
-    configResolved(config) {
+    configResolved(config: ResolvedConfig) {
       root = config.root;
     },
-    async resolveId(id, importer) {
+    async resolveId(id: string, importer: string | undefined) {
       if (id.startsWith("npm:")) {
         const resolved = await resolveDeno(id, root);
         if (resolved === null) return;

packages/deno-vite-plugin/src/resolvePlugin.ts

@@ -1,4 +1,4 @@
-import { Plugin } from "vite";
+import { type Plugin, type ResolvedConfig } from "vite";
 import {
   type DenoMediaType,
   type DenoResolveResult,
@@ -17,16 +17,16 @@ export default function denoPlugin(
 
   return {
     name: "deno",
-    configResolved(config) {
+    configResolved(config: ResolvedConfig) {
       root = config.root;
     },
-    async resolveId(id, importer) {
+    async resolveId(id: string, importer: string | undefined) {
       // The "pre"-resolve plugin already resolved it
       if (isDenoSpecifier(id)) return;
 
       return await resolveViteSpecifier(id, cache, root, importer);
     },
-    async load(id) {
+    async load(id: string) {
       if (!isDenoSpecifier(id)) return;
 
       const { loader, resolved } = parseDenoSpecifier(id);

packages/jumble/src/main.tsx

@@ -31,6 +31,15 @@ import { ActivityProvider } from "@/contexts/ActivityContext.tsx";
 import { RuntimeProvider } from "@/contexts/RuntimeContext.tsx";
 import { ROUTES } from "@/routes.ts";
 
+declare global {
+  interface ImportMeta {
+    readonly env: {
+      readonly VITE_COMMIT_SHA?: string;
+      [key: string]: string | undefined;
+    };
+  }
+}
+
 // Determine environment based on hostname
 const determineEnvironment = () => {
   const hostname = globalThis.location.hostname;

packages/memory/traverse.ts

@@ -233,7 +233,7 @@ export function getAtPath<K, S>(
     );
   }
   let cursor = fact;
-  for (const [index, part] of path.entries()) {
+  for (const [_index, part] of path.entries()) {
     // TODO(@ubik2) Call toJSON on object if it's a function?
     if (isPointer(cursor)) {
       [doc, docRoot, cursor] = followPointer(
@@ -247,7 +247,7 @@ export function getAtPath<K, S>(
       const cursorObj = cursor as JSONObject;
       cursor = cursorObj[part] as JSONValue;
     } else if (Array.isArray(cursor)) {
-      cursor = elementAt(cursor, part) as JSONValue;
+      cursor = elementAt(cursor, part) as JSONValue | undefined;
     } else {
       // we can only descend into pointers, objects, and arrays
       return [doc, docRoot, undefined];
@@ -368,7 +368,10 @@ function isJSONCellLink(value: unknown): value is JSONCellLink {
     Array.isArray(value.path));
 }
 
-export function indexFromPath(array: unknown[], path: string): number | undefined {
+export function indexFromPath(
+  array: unknown[],
+  path: string,
+): number | undefined {
   const number = new Number(path).valueOf();
   return (Number.isInteger(number) && number >= 0 && number < array.length)
     ? number

packages/runner/src/cell.ts

@@ -362,9 +362,9 @@ function createRegularCell<T>(
       // Hacky retry logic for push only. See storage.ts for details on this
       // retry approach and what we should really be doing instead.
       if (!ref.cell.retry) ref.cell.retry = [];
-      ref.cell.retry.push((newBaseValue: any[]) => {
+      ref.cell.retry.push((newBaseValue) => {
         // Unlikely, but maybe the conflict reset to undefined?
-        if (newBaseValue === undefined) {
+        if (!Array.isArray(newBaseValue)) {
           newBaseValue = Array.isArray(schema?.default) ? schema.default : [];
         }
 
@@ -373,7 +373,7 @@ function createRegularCell<T>(
         const newValues = JSON.parse(JSON.stringify(appended));
 
         // Reappend the new values.
-        return [...newBaseValue, ...newValues];
+        return [...(newBaseValue as unknown[]), ...newValues];
       });
     },
     equals: (other: Cell<any>) =>

packages/runner/src/doc-map.ts

@@ -38,8 +38,11 @@ export function createRef(
     if (isRecord(obj) && "/" in obj) return obj;
 
     // If there is a .toJSON method, replace obj with it, then descend.
+    // TODO(seefeld): We have to accept functions for now as the recipe factory
+    // is a function and has a .toJSON method. But we plan to move away from
+    // that kind of serialization anyway, so once we did, remove this.
     if (
-      isRecord(obj) &&
+      (isRecord(obj) || typeof obj === "function") &&
       typeof obj.toJSON === "function"
     ) {
       obj = obj.toJSON() ?? obj;

packages/runner/src/runner.ts

@@ -90,7 +90,7 @@ export class Runner implements IRunner {
     let processCell: DocImpl<{
       [TYPE]: string;
       argument?: T;
-      internal?: { [key: string]: any };
+      internal?: JSONValue;
       resultRef: { cell: DocImpl<R>; path: PropertyKey[] };
     }>;
 
@@ -182,18 +182,25 @@ export class Runner implements IRunner {
     }
 
     // Walk the recipe's schema and extract all default values
-    const defaults = extractDefaultValues(recipe.argumentSchema);
-
-    const internal = {
-      ...(deepCopy((defaults as { internal: any })?.internal) as any),
-      ...(deepCopy((recipe.initial as { internal: any })?.internal) as any),
-      ...processCell.get()?.internal,
-    };
+    const defaults = extractDefaultValues(recipe.argumentSchema) as Partial<T>;
+
+    // Important to use DeepCopy here, as the resulting object will be modified!
+    const previousInternal = processCell.get()?.internal;
+    const internal: JSONValue = Object.assign(
+      {},
+      deepCopy((defaults as unknown as { internal: JSONValue })?.internal),
+      deepCopy(
+        isRecord(recipe.initial) && isRecord(recipe.initial.internal)
+          ? recipe.initial.internal
+          : {},
+      ),
+      isRecord(previousInternal) ? previousInternal : {},
+    );
 
     // Still necessary until we consistently use schema for defaults.
     // Only do it on first load.
     if (!processCell.get()?.argument) {
-      argument = mergeObjects(argument as any, defaults) as T;
+      argument = mergeObjects<T>(argument as any, defaults);
     }
 
     const recipeChanged = recipeId !== processCell.get()?.[TYPE];

packages/runner/src/schema.ts

@@ -4,7 +4,7 @@ import { type CellLink, createCell, isCell, isCellLink } from "./cell.ts";
 import { type ReactivityLog } from "./scheduler.ts";
 import { resolveLinks, resolveLinkToAlias } from "./utils.ts";
 import { ContextualFlowControl } from "./index.ts";
-import { isRecord, type Mutable } from "@commontools/utils/types";
+import { isObject, isRecord, type Mutable } from "@commontools/utils/types";
 
 /**
  * Schemas are mostly a subset of JSONSchema.
@@ -134,7 +134,7 @@ function processDefaultValue(
 
   // Handle object type defaults
   if (
-    resolvedSchema?.type === "object" && isRecord(defaultValue)
+    resolvedSchema?.type === "object" && isObject(defaultValue)
   ) {
     const result: Record<string, any> = {};
     const processedKeys = new Set<string>();
@@ -148,7 +148,7 @@ function processDefaultValue(
           result[key] = processDefaultValue(
             doc,
             [...path, key],
-            defaultValue[key],
+            defaultValue[key as keyof typeof defaultValue],
             propSchema,
             log,
             rootSchema,
@@ -202,7 +202,7 @@ function processDefaultValue(
           result[key] = processDefaultValue(
             doc,
             [...path, key],
-            defaultValue[key],
+            defaultValue[key as keyof typeof defaultValue],
             additionalPropertiesSchema,
             log,
             rootSchema,

packages/runner/src/utils.ts

@@ -1,4 +1,5 @@
 import {
+  type Alias,
   ID,
   ID_FIELD,
   isAlias,
@@ -22,7 +23,7 @@ import {
 import { type CellLink, isCell, isCellLink } from "./cell.ts";
 import { type ReactivityLog } from "./scheduler.ts";
 import { ContextualFlowControl } from "./index.ts";
-import { isObject, isRecord } from "@commontools/utils/types";
+import { isObject, isRecord, type Mutable } from "@commontools/utils/types";
 
 /**
  * Extracts default values from a JSON schema object.
@@ -37,10 +38,14 @@ export function extractDefaultValues(
   if (
     schema.type === "object" && schema.properties && isObject(schema.properties)
   ) {
-    const obj = deepCopy(schema.default ?? {}) as Record<string, JSONValue>;
+    // Ignore the schema.default if it's not an object, since it's not a valid
+    // default value for an object.
+    const obj = deepCopy(isRecord(schema.default) ? schema.default : {});
     for (const [propKey, propSchema] of Object.entries(schema.properties)) {
       const value = extractDefaultValues(propSchema);
-      if (value !== undefined) obj[propKey] = value;
+      if (value !== undefined) {
+        (obj as Record<string, unknown>)[propKey] = value;
+      }
     }
 
     return Object.entries(obj).length > 0 ? obj : undefined;
@@ -56,12 +61,12 @@ export function extractDefaultValues(
  * @param objects - Objects to merge
  * @returns A merged object, or undefined if no objects provided
  */
-export function mergeObjects<T extends Record<string, unknown>>(
-  ...objects: (T | undefined)[]
-): T | undefined {
+export function mergeObjects<T>(
+  ...objects: (Partial<T> | undefined)[]
+): T {
   objects = objects.filter((obj) => obj !== undefined);
-  if (objects.length === 0) return undefined;
-  if (objects.length === 1) return objects[0];
+  if (objects.length === 0) return {} as T;
+  if (objects.length === 1) return objects[0] as T;
 
   const seen = new Set<PropertyKey>();
   const result: Record<string, unknown> = {};
@@ -80,14 +85,18 @@ export function mergeObjects<T extends Record<string, unknown>>(
       isCell(obj) ||
       isStatic(obj)
     ) {
-      return obj;
+      return obj as T;
     }
 
     // Then merge objects, only passing those on that have any values.
     for (const key of Object.keys(obj)) {
       if (seen.has(key)) continue;
       seen.add(key);
-      const merged = mergeObjects(...objects.map((obj) => obj?.[key] as T));
+      const merged = mergeObjects<T[keyof T]>(
+        ...objects.map((obj) =>
+          (obj as Record<string, unknown>)?.[key] as T[keyof T]
+        ),
+      );
       if (merged !== undefined) result[key] = merged;
     }
   }
@@ -302,7 +311,7 @@ export function findAllAliasedCells<T>(
       const doc = (binding.$alias.cell ?? origDoc) as DocImpl<T>;
       const path = binding.$alias.path;
       if (docs.find((c) => c.cell === doc && c.path === path)) return;
-      docs.push({ cell: doc, path });
+      docs.push({ cell: doc as DocImpl<unknown>, path });
       find(doc.getAtPath(path), doc);
     } else if (Array.isArray(binding)) {
       for (const value of binding) find(value, origDoc);
@@ -562,21 +571,21 @@ export function maybeGetCellLink<T>(
 
 // Follows aliases and returns cell reference describing the last alias.
 // Only logs interim aliases, not the first one, and not the non-alias value.
-export function followAliases<T>(
-  alias: unknown,
+export function followAliases<T = any>(
+  alias: Alias,
   doc: DocImpl<T>,
   log?: ReactivityLog,
 ): CellLink {
-  if (!isAlias(alias)) {
+  if (isAlias(alias)) {
+    return followLinks(
+      { cell: doc, ...alias.$alias } as CellLink,
+      log,
+      createVisits(),
+      true,
+    );
+  } else {
     throw new Error(`Alias expected: ${JSON.stringify(alias)}`);
   }
-
-  return followLinks(
-    { cell: doc, ...(alias as any).$alias },
-    log,
-    createVisits(),
-    true,
-  );
 }
 
 /**
@@ -955,14 +964,17 @@ export function containsOpaqueRef(value: unknown): boolean {
   return false;
 }
 
-export function deepCopy(value: unknown): unknown {
+export function deepCopy<T = unknown>(value: T): Mutable<T> {
   if (isQueryResultForDereferencing(value)) {
-    return deepCopy(getCellLinkOrThrow(value));
+    return deepCopy(getCellLinkOrThrow(value)) as unknown as Mutable<T>;
   }
-  if (isDoc(value) || isCell(value)) return value;
+  if (isDoc(value) || isCell(value)) return value as Mutable<T>;
   if (isRecord(value)) {
-    return Array.isArray(value) ? value.map(deepCopy) : Object.fromEntries(
-      Object.entries(value).map(([key, value]) => [key, deepCopy(value)]),
-    );
-  } else return value;
+    return Array.isArray(value)
+      ? value.map(deepCopy) as unknown as Mutable<T>
+      : Object.fromEntries(
+        Object.entries(value).map(([key, value]) => [key, deepCopy(value)]),
+      ) as unknown as Mutable<T>;
+    // Literal value:
+  } else return value as Mutable<T>;
 }