Initial commit

Author: AnyhowStep

.gitignore

@@ -0,0 +1,3 @@
+node_modules
+dist
+test/compile-time/actual-output/*

package-lock.json

@@ -0,0 +1,25 @@
+{
+  "name": "type-mapping",
+  "version": "1.0.0",
+  "description": "Map input data safely",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "test-compile-time": "ts-node -P ./test/compile-time/tsconfig.json ./test/compile-time/runner.ts",
+    "accept-compile-time": "ts-node -P ./test/compile-time/tsconfig.json ./test/compile-time/accept-actual.ts",
+    "accept-one": "ts-node -P ./test/compile-time/tsconfig.json ./test/compile-time/accept-one.ts",
+    "test-compile-time-interactive": "ts-node -P ./test/compile-time/tsconfig.json ./test/compile-time/interactive.ts"
+  },
+  "author": "anyhowstep",
+  "license": "MIT",
+  "devDependencies": {
+    "ts-node": "^8.1.0",
+    "typescript": "^3.5.0-dev.20190523"
+  },
+  "dependencies": {
+    "@types/diff": "^4.0.2",
+    "diff": "^4.0.1"
+  }
+}

package.json

@@ -0,0 +1,19 @@
+import {AnyTypeMapDelegate, TypeMapDelegate} from "./type-map-delegate";
+import {Accepts} from "./accepts";
+import {CanAccept} from "./can-accept";
+
+export type AcceptsOfImpl<F extends AnyTypeMapDelegate> = (
+    F extends TypeMapDelegate<infer T, any> ?
+    (
+        unknown extends T ?
+        (
+            F extends Accepts<infer T> ?
+            [T] :
+            F extends CanAccept<infer T> ?
+            [T] :
+            [unknown]
+        ) :
+        [T]
+    ) :
+    never
+);

src/accepts-of-impl.ts

@@ -0,0 +1,10 @@
+import {AnyTypeMapDelegate} from "./type-map-delegate";
+import {AcceptsOfImpl} from "./accepts-of-impl";
+import {UnionToIntersection} from "./type-operation";
+
+export type AcceptsOf<F extends AnyTypeMapDelegate> = (
+    Extract<
+        UnionToIntersection<AcceptsOfImpl<F>>,
+        [any]
+    >[0]
+);

src/accepts-of.ts

@@ -0,0 +1,9 @@
+/**
+    Meant to be a subtype of `CanAccept<>`.
+
+    Says that the `SafeTypeMapDelegate<>`
+    WANTS to accept certain data types.
+*/
+export interface Accepts<T> {
+    accepts? : [T],
+}

src/accepts.ts

@@ -0,0 +1,19 @@
+import {AnyTypeMapDelegate, TypeMapDelegate} from "./type-map-delegate";
+import {Accepts} from "./accepts";
+import {CanAccept} from "./can-accept";
+
+export type CanAcceptOfImpl<F extends AnyTypeMapDelegate> = (
+    F extends TypeMapDelegate<infer T, any> ?
+    (
+        unknown extends T ?
+        (
+            F extends CanAccept<infer T> ?
+            [T] :
+            F extends Accepts<infer T> ?
+            [T] :
+            [unknown]
+        ) :
+        [T]
+    ) :
+    never
+);

src/can-accept-of-impl.ts

@@ -0,0 +1,10 @@
+import {AnyTypeMapDelegate} from "./type-map-delegate";
+import {CanAcceptOfImpl} from "./can-accept-of-impl";
+import {UnionToIntersection} from "./type-operation";
+
+export type CanAcceptOf<F extends AnyTypeMapDelegate> = (
+    Extract<
+        UnionToIntersection<CanAcceptOfImpl<F>>,
+        [any]
+    >[0]
+);

src/can-accept-of.ts

@@ -0,0 +1,12 @@
+/**
+    Helper type that says a `SafeTypeMapDelegate<>`
+    CAN accept certain data types,
+    and not throw an Error in general.
+
+    Just because the `SafeTypeMapDelegate<>`
+    CAN accept the data type, doesn't mean
+    it actually WANTS to accept it.
+*/
+export interface CanAccept<T> {
+    canAccept? : [T],
+}

src/can-accept.ts

@@ -0,0 +1,12 @@
+import {SafeTypeMapDelegate} from "./safe-type-map-delegate";
+import {ResultOf} from "./result-of";
+
+export interface IField<
+    NameT extends string,
+    F extends SafeTypeMapDelegate<any>
+> extends SafeTypeMapDelegate<ResultOf<F>> {
+    name : NameT,
+}
+export type AnyField = (
+    IField<any, any>
+);

src/field.ts

@@ -0,0 +1,8 @@
+export * from "./type-map-delegate";
+export * from "./safe-type-map-delegate";
+export * from "./accepts";
+export * from "./can-accept";
+
+export * from "./accepts-of";
+export * from "./can-accept-of";
+export * from "./result-of";

src/index.ts

@@ -0,0 +1,8 @@
+import {AnyTypeMapDelegate} from "./type-map-delegate";
+
+/**
+    Gives you the return type of a `TypeMapDelegate<>`
+*/
+export type ResultOf<F extends AnyTypeMapDelegate> = (
+    ReturnType<F>
+);

src/result-of.ts

@@ -0,0 +1,11 @@
+import {TypeMapDelegate} from "./type-map-delegate";
+
+/**
+    You should generally just use `SafeTypeMapDelegate<>`
+    because it is more likely to throw an Error instead
+    of silently mapping invalid values.
+*/
+export type SafeTypeMapDelegate<ResultT> = (
+    TypeMapDelegate<unknown, ResultT>
+);
+

src/safe-type-map-delegate.ts

@@ -0,0 +1,15 @@
+/**
+    A `TypeMapDelegate<>` must satisfy the following,
+
+    ```ts
+    deepEquals(f(x), f(f(x)))
+    ```
+
+    That is, if `f(0)` is `"hello"`, then `f("hello")` must be `f("hello")`.
+*/
+export interface TypeMapDelegate<AcceptsT, ResultT> {
+    (name : string, mixed : AcceptsT) : ResultT,
+}
+export type AnyTypeMapDelegate = (
+    TypeMapDelegate<any, any>
+);

src/type-map-delegate.ts

@@ -0,0 +1,7 @@
+export type UnionToIntersection<U> = (
+    (
+        U extends any ? (k: U) => void : never
+    ) extends (
+        (k: infer I) => void
+    ) ? I : never
+);

src/type-operation.ts

@@ -0,0 +1,92 @@
+### Note
+
+This project is meant to provide compile-time safety.
+
+This means we have a few compile-time requirements,
+
++ Correct code should compile *with the right types*
++ Incorrect code should not compile *with the right errors*
+
+-----
+
+### Correct code should compile *with the right types*
+
+An example of compiling with the right types would be,
+
+Given this input,
+
+```ts
+import * as sd from "schema-decorator";
+import * as o from "typed-orm";
+
+export const t = o.table(
+    "someTableName",
+    {
+        x : sd.naturalNumber(),
+        y : sd.naturalNumber(),
+    }
+);
+```
+
+If we get this output,
+
+```ts
+import * as sd from "schema-decorator";
+import * as o from "typed-orm";
+
+export declare const t: o.Table<{
+    readonly alias: string;
+    readonly name: string;
+/*snip*/
+```
+
+Then we fail the test because `alias` and `name` should be of type `"someTableName"`, the string literal!
+
+-----
+
+### Incorrect code should not compile *with the right errors*
+
+Given this input,
+
+```ts
+import * as sd from "schema-decorator";
+import * as o from "typed-orm";
+
+export const t = o.table(
+    232,
+    {
+        x : sd.naturalNumber(),
+        y : sd.naturalNumber(),
+    }
+);
+```
+
+We expect this output,
+
+```json
+{
+    "messageText": "Argument of type '232' is not assignable to parameter of type 'string'.",
+    "code": 2345,
+    "category": 1,
+    "length": 3,
+    "start": 232
+}
+```
+
+If we get something else, we fail the test.
+
+-----
+
+### Implementing Tests
+
+1. Write the input `.ts` file in the `input` folder
+2. Run `npm run test-compile-time`
+
+You may get errors about expected output being missing, or the actual and expected output being different.
+
+You can now do one of the following,
+
++ Fix the code, and run the test again
++ Accept that this "actual" output is, in fact, correct.
+
+If it is correct, run `npm run accept-compile-time`

test/compile-time/README.md

@@ -0,0 +1,18 @@
+import * as fs from "fs";
+import {
+    actualOutputRoot,
+    expectedOutputRoot,
+    removeAllFilesAndDirectoriesSync,
+    copyAllFilesAndDirectoriesSync,
+} from "./util";
+
+if (fs.readdirSync(actualOutputRoot).length == 0) {
+    throw new Error(`No files in actual output, have you run the test?`);
+}
+
+removeAllFilesAndDirectoriesSync(expectedOutputRoot);
+copyAllFilesAndDirectoriesSync(
+    actualOutputRoot,
+    expectedOutputRoot,
+);
+removeAllFilesAndDirectoriesSync(actualOutputRoot);