start strictifying..

packages/absurd-sql-connector/src/worker/worker.ts

@@ -1,5 +1,6 @@
 import initSqlJs from '@aphro/sql.js';
 import { SQLiteFS } from '@aphro/absurd-sql';
+// @ts-ignore
 import IndexedDBBackend from '@aphro/absurd-sql/dist/indexeddb-backend.js';
 import thisPackage from '../pkg.js';
 import tracer from '../tracer.js';
@@ -11,7 +12,7 @@ import tracer from '../tracer.js';
  */
 async function init() {
   let SQL = await initSqlJs({
-    locateFile: file => {
+    locateFile: (file: string) => {
       return file;
     },
   });

packages/cache-runtime-ts/src/__tests__/Cache.test.ts

@@ -2,7 +2,9 @@ import Cache from '../cache.js';
 import { asId, SID_of } from '@strut/sid';
 import fc from 'fast-check';
 
-declare const global;
+declare const global: {
+  gc: () => void;
+};
 
 // TODO: cache will need to be per viewer......
 // Why would we have many viewers in local first P2P app? For privacy respecting replications to other peers.
@@ -81,7 +83,7 @@ test('purges refs after garbage collection', async () => {
   expect(cache.get(id, db, tablish)).toBe(null);
 });
 
-function mkModel(id) {
+function mkModel(id: SID_of<TestModel>) {
   return new TestModel(id);
 }
 

packages/codegen-cli/src/cli.ts

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 
+// @ts-ignore
 import commandLineArgs from 'command-line-args';
+// @ts-ignore
 import commandLineUsage from 'command-line-usage';
+
 import { CodegenPipeline } from '@aphro/codegen';
 import * as process from 'process';
 import * as path from 'path';

packages/context-runtime-ts/src/INode.ts

@@ -20,7 +20,7 @@ export interface IModel<T extends {} = Object> {
   subscribe(c: () => void): Disposer;
   subscribeTo(keys: (keyof T)[], c: () => void): Disposer;
 
-  destroy();
+  destroy(): void;
 
   // Internal only APIs. Exposed since TS doesn't understand package friends.
   // TODO: Or does it? I can extend a type that exists in a package from another package...

packages/context-runtime-ts/src/OptimisticPromise.ts

@@ -2,6 +2,7 @@
  * Complicates the code and is only a problem because React can't handle async correctly.
  */
 export default class OptimisticPromise<T> extends Promise<T> {
+  // @ts-ignore
   #optimistic: T;
 
   get optimistic(): T {

packages/context-runtime-ts/src/resolvers.ts

@@ -1,7 +1,7 @@
 import { StorageEngine, StorageType } from '@aphro/schema-api';
 import { DBResolver, EngineToResolved, ResolvedDB } from './DBResolver.js';
 
-export const printResolver: DBResolver = spyResolver(function() {
+export const printResolver: DBResolver = spyResolver(function () {
   console.log(arguments);
 });
 
@@ -31,14 +31,14 @@ export function spyResolver(spy: (...args: any) => any): DBResolver {
 
 function spyProxy(spy: (...args: any[]) => any) {
   const objProxyDef = {
-    get(target, prop, receiver) {
+    get(target: any, prop: any, receiver: any): any {
       spy(prop);
       return new Proxy(() => {}, fnProxyDef);
     },
   };
 
   const fnProxyDef = {
-    apply(target, thisArg, args) {
+    apply(target: any, thisArg: any, args: any): any {
       spy(args);
       return new Proxy({}, objProxyDef);
     },
@@ -53,7 +53,7 @@ export function basicResolver<X extends StorageEngine>(resolved: EngineToResolve
       return {
         db(db: string) {
           // TOOD: some sort of invariant to ensure E === X?
-          return (resolved as unknown) as EngineToResolved[E];
+          return resolved as unknown as EngineToResolved[E];
         },
       };
     },

packages/instrument/src/tracer.ts

@@ -1,4 +1,4 @@
-import { Span, trace } from '@opentelemetry/api';
+import { Span, SpanStatusCode, trace } from '@opentelemetry/api';
 
 export type Tracer = ReturnType<typeof getTracer>;
 
@@ -14,7 +14,14 @@ export default function getTracer(pkg: string, version: string) {
         try {
           return cb(span);
         } catch (e) {
-          span.recordException(e);
+          if (e instanceof Error) {
+            span.recordException(e);
+          } else {
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: (e as any)?.message,
+            });
+          }
           throw e;
         } finally {
           span.end();
@@ -27,7 +34,14 @@ export default function getTracer(pkg: string, version: string) {
         try {
           return await cb(span);
         } catch (e) {
-          span.recordException(e);
+          if (e instanceof Error) {
+            span.recordException(e);
+          } else {
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: (e as any)?.message,
+            });
+          }
           throw e;
         } finally {
           span.end();
@@ -40,7 +54,14 @@ export default function getTracer(pkg: string, version: string) {
       try {
         return await cb();
       } catch (e) {
-        span.recordException(e);
+        if (e instanceof Error) {
+          span.recordException(e);
+        } else {
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: (e as any)?.message,
+          });
+        }
         throw e;
       } finally {
         span.end();
@@ -52,7 +73,14 @@ export default function getTracer(pkg: string, version: string) {
       try {
         return cb();
       } catch (e) {
-        span.recordException(e);
+        if (e instanceof Error) {
+          span.recordException(e);
+        } else {
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: (e as any)?.message,
+          });
+        }
         throw e;
       } finally {
         span.end();

packages/migration-runtime-ts/src/autoMigrate.ts

@@ -49,7 +49,7 @@ async function migrateAllTasksForDB(db: SQLResolvedDB, tasks: MigrationTask[]) {
     await db.query(sql`ROLLBACK`);
     throw {
       cause: e,
-      message: 'Failed to commit the migration. Rolling it back. ' + e.message,
+      message: 'Failed to commit the migration. Rolling it back. ' + (e as any)?.message,
     };
   }
 }

packages/migration-runtime-ts/src/bootstrap.ts

@@ -5,6 +5,7 @@ import { autoMigrate, CreateError } from './autoMigrate.js';
 export type SQLExports = { sqlite: DBs };
 type DBs = { [dbName: string]: Schemas };
 type Schemas = { [key: string]: string };
+type Engine = 'sqlite';
 
 export const bootstrap = {
   /**
@@ -16,7 +17,7 @@ export const bootstrap = {
   async createIfNotExists(
     resolver: DBResolver,
     sqlExports: SQLExports,
-    engine?: string,
+    engine?: Engine,
     db?: string,
   ) {
     await create(
@@ -41,7 +42,7 @@ export const bootstrap = {
   async createThrowIfExists(
     resolver: DBResolver,
     sqlExports: SQLExports,
-    engine?: string,
+    engine?: Engine,
     db?: string,
   ) {
     await create(
@@ -68,7 +69,7 @@ export const bootstrap = {
   async createAutomigrateIfExists(
     resolver: DBResolver,
     sqlExports: SQLExports,
-    engine?: string,
+    engine?: Engine,
     db?: string,
   ) {
     let tryToMigrate: CreateError[] = [];
@@ -99,21 +100,21 @@ async function create(
   resolver: DBResolver,
   sqlExports: SQLExports,
   errorHandler: (r: PromiseSettledResult<void>) => void,
-  engine?: string,
+  engine?: Engine,
   db?: string,
 ) {
   if (engine != null) {
     await createForEngine(resolver, engine, sqlExports[engine], errorHandler, db);
     return;
   }
-  for (const [engine, dbs] of Object.entries(sqlExports)) {
+  for (const [engine, dbs] of Object.entries(sqlExports) as [Engine, DBs][]) {
     await createForEngine(resolver, engine, dbs, errorHandler);
   }
 }
 
 async function createForEngine(
   resolver: DBResolver,
-  engine: string,
+  engine: Engine,
   dbs: DBs,
   errorHandler: (r: PromiseSettledResult<void>) => void,
   db?: string,

packages/model-runtime-ts/src/Model.ts

@@ -15,6 +15,7 @@ export default abstract class Model<T extends {}> implements IModel<T> {
   private subscriptions: Set<() => void> = new Set();
   private keyedSubscriptions: Map<keyof T, Set<() => void>> = new Map();
 
+  // @ts-ignore
   #generatorChange: (x: this) => this;
   #generator: ReturnType<typeof observe>;
   #generatorUsed: boolean = false;
@@ -69,7 +70,7 @@ export default abstract class Model<T extends {}> implements IModel<T> {
 
     let unchangedKeys = new Set();
     if (newData != null) {
-      Object.entries(newData).forEach(entry => {
+      (Object.entries(newData) as [keyof Partial<T>, any][]).forEach(entry => {
         if (lastData[entry[0]] === entry[1]) {
           unchangedKeys.add(entry[0]);
         }
@@ -87,7 +88,9 @@ export default abstract class Model<T extends {}> implements IModel<T> {
   }
 
   _isNoop(updates: Partial<T>) {
-    return Object.entries(updates).every(entry => this.data[entry[0]] === entry[1]);
+    return (Object.entries(updates) as [keyof Partial<T>, any][]).every(
+      entry => this.data[entry[0]] === entry[1],
+    );
   }
 
   private gatherNotifications(changedKeys?: (keyof T)[]): Set<() => void> {

packages/model-runtime-ts/src/modelDataEncoding.ts

@@ -20,12 +20,14 @@ export function decodeModelData<D>(data: any, spec: FieldsSpec): D {
 }
 
 export function encodeModelData<D>(data: D, spec: FieldsSpec): any {
-  const encodedFields = Object.entries(spec).filter(([key, value]) => value.encoding !== 'none');
+  const encodedFields = (Object.entries(spec) as [keyof D, any][]).filter(
+    ([key, value]) => value.encoding !== 'none',
+  );
   if (encodedFields.length === 0) {
     return data;
   }
 
-  const ret = {
+  const ret: { [Prop in keyof D]: any } = {
     ...data,
   };
 
@@ -34,7 +36,7 @@ export function encodeModelData<D>(data: D, spec: FieldsSpec): any {
     if (value.encoding === 'json') {
       ret[key] = JSON.stringify(ret[key]);
     } else {
-      throw new Error(`Unsupported encoding ${value} on field ${key}`);
+      throw new Error(`Unsupported encoding ${value} on field ${String(key)}`);
     }
   });
 

packages/model-runtime-ts/src/that.ts

@@ -1,3 +1,3 @@
-export default function that() {
+export default function that(this: any) {
   return this;
 }

packages/mutator-runtime-ts/src/commit.ts

@@ -44,7 +44,7 @@ export function commit<T extends readonly Changeset<any, any>[]>(
     const transaction = new ChangesetExecutor(ctx, changesets).execute();
 
     const optimistic = changesets.map(cs => transaction.nodes.get(cs.id));
-    let result;
+    let result: any;
     if (singular) {
       result = optimistic[0];
     } else {

packages/parse-ts/src/nodeChildren.ts

@@ -3,7 +3,7 @@ import ts from 'typescript';
 
 export function filter<S extends ts.Node>(n: ts.Node, pred: (n: ts.Node) => n is S): S[] {
   const ret: S[] = [];
-  n.forEachChild(c => {
+  n.forEachChild((c: ts.Node) => {
     if (pred(c)) {
       ret.push(c);
     }
@@ -13,7 +13,7 @@ export function filter<S extends ts.Node>(n: ts.Node, pred: (n: ts.Node) => n is
 
 export function map<R>(n: ts.Node, m: (n: ts.Node) => R): R[] {
   const ret: R[] = [];
-  n.forEachChild(c => {
+  n.forEachChild((c: ts.Node) => {
     ret.push(m(c));
   });
   return ret;

packages/query-runtime-ts/src/ChunkIterable.ts

@@ -91,7 +91,7 @@ export class PromiseSourceSingleChunkIterable<T> extends BaseChunkIterable<T> {
 }
 
 export class MappedChunkIterable<TIn, TOut> extends BaseChunkIterable<TOut> {
-  constructor(private source: ChunkIterable<TIn>, private fn: (TIn) => Promise<TOut>) {
+  constructor(private source: ChunkIterable<TIn>, private fn: (x: TIn) => Promise<TOut>) {
     super();
   }
 
@@ -103,7 +103,7 @@ export class MappedChunkIterable<TIn, TOut> extends BaseChunkIterable<TOut> {
 }
 
 export class SyncMappedChunkIterable<TIn, TOut> extends BaseChunkIterable<TOut> {
-  constructor(private source: ChunkIterable<TIn>, private fn: (TIn) => TOut) {
+  constructor(private source: ChunkIterable<TIn>, private fn: (x: TIn) => TOut) {
     super();
   }
 
@@ -115,7 +115,7 @@ export class SyncMappedChunkIterable<TIn, TOut> extends BaseChunkIterable<TOut>
 }
 
 export class FilteredChunkIterable<T> extends BaseChunkIterable<T> {
-  constructor(private source: ChunkIterable<T>, private fn: (T) => Promise<boolean>) {
+  constructor(private source: ChunkIterable<T>, private fn: (x: T) => Promise<boolean>) {
     super();
   }
 
@@ -136,7 +136,7 @@ export class FilteredChunkIterable<T> extends BaseChunkIterable<T> {
 }
 
 export class SyncFilteredChunkIterable<T> extends BaseChunkIterable<T> {
-  constructor(private source: ChunkIterable<T>, private fn: (T) => boolean) {
+  constructor(private source: ChunkIterable<T>, private fn: (x: T) => boolean) {
     super();
   }
 

packages/query-runtime-ts/src/Expression.ts

@@ -46,19 +46,19 @@ export type ExpressionType =
 
 export type Direction = 'asc' | 'desc';
 export type Expression =
-  | ReturnType<typeof take>
-  | ReturnType<typeof before>
-  | ReturnType<typeof after>
-  | ReturnType<typeof filter>
-  | ReturnType<typeof filterAsync>
-  | ReturnType<typeof orderBy>
-  | ReturnType<typeof orderByLambda>
-  | ReturnType<typeof hop>
-  | ReturnType<typeof modelLoad>
-  | ReturnType<typeof count>
+  | ReturnType<typeof take<any>>
+  | ReturnType<typeof before<any>>
+  | ReturnType<typeof after<any>>
+  | ReturnType<typeof filter<any, any>>
+  | ReturnType<typeof filterAsync<any, any>>
+  | ReturnType<typeof orderBy<any, any>>
+  | ReturnType<typeof orderByLambda<any>>
+  | ReturnType<typeof hop<any, any>>
+  | ReturnType<typeof modelLoad<any, any>>
+  | ReturnType<typeof count<any>>
   | CountLoadExpression<any>
-  | ReturnType<typeof map>
-  | ReturnType<typeof mapAsync>;
+  | ReturnType<typeof map<any, any>>
+  | ReturnType<typeof mapAsync<any, any>>;
 /*
 declare module '@mono/model/query' {
   interface Expressions<ReturnType> {