@shapecraft/core 1.0.0

package/src/common/index.ts

@@ -0,0 +1,5 @@
+export * from "./is";
+export * from "./phantom";
+export * from "./result";
+export * from "./array";
+export * from "./string";

package/src/common/is.ts

@@ -0,0 +1,23 @@
+export const isPlainObject = (x: any): x is Record<PropertyKey, unknown> => {
+  if (x === null || typeof x === "undefined") return false;
+  if (Array.isArray(x)) return false;
+  if (x instanceof Date) return false;
+  if (typeof x !== "object") return false;
+  return Object.getPrototypeOf(x) === Object.prototype;
+};
+
+export const isSafeNumber = (x: number): boolean => {
+  if (isNaN(x)) return false;
+  if (!isFinite(x)) return false;
+  return true;
+};
+
+export const isSafeFloat = (x: number): boolean => {
+  if (!isSafeNumber(x)) return false;
+  if (Number.isInteger(x)) return false;
+  return true;
+};
+
+export const isNumeric = (str: string): boolean => {
+  return !isNaN(Number(str)) && !isNaN(parseFloat(str));
+};

package/src/common/object.ts

@@ -0,0 +1,35 @@
+import { LooseRecord } from "./types";
+
+export const remapObjectValues = <
+  Obj extends LooseRecord,
+  Fn extends (kv: [keyof Obj, Obj[keyof Obj]]) => any,
+>(
+  obj: Obj,
+  fn: Fn,
+): Record<keyof Obj, ReturnType<Fn>> => {
+  const entries = Object.entries(obj) as Array<[keyof Obj, Obj[keyof Obj]]>;
+  return Object.assign(
+    {},
+    ...entries.map((kv) => {
+      return {
+        [kv[0]]: fn(kv),
+      };
+    }),
+  );
+};
+
+export const remapObjectEntries = <
+  Obj extends LooseRecord,
+  Fn extends (kv: [keyof Obj, Obj[keyof Obj]]) => LooseRecord,
+>(
+  obj: Obj,
+  fn: Fn,
+): ReturnType<Fn> => {
+  const entries = Object.entries(obj) as Array<[keyof Obj, Obj[keyof Obj]]>;
+  return Object.assign(
+    {},
+    ...entries.map((kv) => {
+      return fn(kv);
+    }),
+  );
+};

package/src/common/phantom.ts

@@ -0,0 +1 @@
+export type PhantomType = any;

package/src/common/result.ts

@@ -0,0 +1,43 @@
+import { isPlainObject } from "./is";
+
+export namespace R {
+  export type ResultOk<T> = {
+    value: T;
+    ok: true;
+  };
+
+  export type ResultErr<E> = {
+    error: E;
+    ok: false;
+  };
+
+  export type Result<T, E> = ResultOk<T> | ResultErr<E>;
+
+  export type LooseResult = Result<any, any>;
+
+  export function isResult(x: unknown): x is Result<any, any> {
+    return isPlainObject(x) && typeof x["ok"] === "boolean" && "value" in x;
+  }
+
+  export function isOk<Res extends LooseResult>(
+    res: LooseResult,
+  ): res is Extract<Res, { ok: true }> {
+    return res.ok === true;
+  }
+
+  export function isErr<Res extends LooseResult>(
+    res: LooseResult,
+  ): res is Extract<Res, { ok: false }> {
+    return res.ok === false;
+  }
+
+  export const err = <E>(error: E): ResultErr<E> => ({
+    error,
+    ok: false,
+  });
+
+  export const ok = <T>(value: T): ResultOk<T> => ({
+    value,
+    ok: true,
+  });
+}

package/src/common/string.ts

@@ -0,0 +1,28 @@
+import { range } from "./array";
+
+export const repeat = (x: string, n: number): string =>
+  range(n)
+    .map(() => x)
+    .join("");
+
+export const forceString = (x: unknown): string => {
+  if (typeof x === "string") return x;
+  if (x === null) return "null";
+  if (typeof x === "object") {
+    const r = x as Record<string, unknown>;
+    if (
+      typeof r.toString === "function" &&
+      r.toString !== Object.prototype.toString
+    ) {
+      try {
+        const ret = r.toString();
+        if (typeof ret === "string") return ret;
+      } catch {}
+    }
+  }
+  try {
+    return JSON.stringify(x);
+  } catch {}
+
+  return "";
+};

package/src/common/types.ts

@@ -0,0 +1,34 @@
+export type Tuple<T> =
+  | [T]
+  | [T, T]
+  | [T, T, T]
+  | [T, T, T, T]
+  | [T, ...T[]]
+  | [...T[], T];
+
+export type Arrayish<T> = Tuple<T> | Array<T>;
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type LooseRecord = Record<PropertyKey, any>;
+
+export type Binary = Uint8Array | number[];
+
+type UnionToIntersection<U> =
+  (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I
+  : never;
+
+type LastOf<T> =
+  UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R
+  : never;
+
+type Push<T extends any[], V> = [...T, V];
+
+type TuplifyUnion<T, L = LastOf<T>, N = [T] extends [never] ? true : false> =
+  true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>>, L>;
+
+export type UnionToTuple<T, A extends T[] = []> =
+  TuplifyUnion<T>["length"] extends A["length"] ? [...A]
+  : UnionToTuple<T, [T, ...A]>;

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./shape";

package/src/shape/annotate.ts

@@ -0,0 +1,139 @@
+import { Annotation } from "./annotation";
+import { shapes } from "./shape";
+
+export namespace annotate {
+  export function as<const S extends shapes.Shape, Anno extends Annotation>(
+    shape: S,
+    anno: Anno,
+  ): shapes.Annotated<S, Anno> {
+    return {
+      ...shape,
+      anno: {
+        ...shape.anno,
+        ...anno,
+      },
+    };
+  }
+
+  export const optional = <const S extends shapes.Shape>(
+    shape: S,
+  ): shapes.Annotated<S, { optional: true }> => as(shape, { optional: true });
+
+  export const unique = <const S extends shapes.Shape>(
+    shape: S,
+  ): shapes.Annotated<S, { unique: true }> => as(shape, { unique: true });
+
+  export const uniqueItems = <const S extends shapes.ShapeArray>(
+    shape: S,
+  ): shapes.Annotated<S, { uniqueItems: true }> =>
+    as(shape, { uniqueItems: true });
+
+  export const primary = <const S extends shapes.Shape>(
+    shape: S,
+  ): shapes.Annotated<S, { primary: true }> => as(shape, { primary: true });
+
+  export const defaulted = <
+    const S extends shapes.Shape,
+    Value extends shapes.InferShapeOut<S>,
+  >(
+    shape: S,
+    value: Value,
+  ): shapes.Annotated<S, { default: Value }> => as(shape, { default: value });
+
+  export const described = <
+    const S extends shapes.Shape,
+    Description extends string,
+  >(
+    shape: S,
+    description: Description,
+  ): shapes.Annotated<S, { description: Description }> =>
+    as(shape, { description: description });
+
+  export const titled = <const S extends shapes.Shape, Title extends string>(
+    shape: S,
+    title: Title,
+  ): shapes.Annotated<S, { title: Title }> => as(shape, { title: title });
+
+  export const commented = <
+    const S extends shapes.Shape,
+    Comment extends string,
+  >(
+    shape: S,
+    comment: Comment,
+  ): shapes.Annotated<S, { comment: Comment }> =>
+    as(shape, { comment: comment });
+
+  export const autoIncremented = <const S extends shapes.Shape>(
+    shape: S,
+  ): shapes.Annotated<S, { autoIncrement: true }> =>
+    as(shape, { autoIncrement: true });
+
+  export const foreign = <
+    const S extends shapes.Shape,
+    Table extends string,
+    Column extends string,
+  >(
+    shape: S,
+    table: Table,
+    column: Column,
+  ): shapes.Annotated<S, { foreign: { table: Table; column: Column } }> =>
+    as(shape, { foreign: { table, column } });
+
+  export const min = <
+    const S extends shapes.ShapeString | shapes.ShapeNumber | shapes.ShapeArray,
+    Min extends number,
+  >(
+    shape: S,
+    min: Min,
+  ): shapes.Annotated<S, { min: Min }> => as(shape, { min });
+
+  export const max = <
+    const S extends shapes.ShapeString | shapes.ShapeNumber | shapes.ShapeArray,
+    Max extends number,
+  >(
+    shape: S,
+    max: Max,
+  ): shapes.Annotated<S, { max: Max }> => as(shape, { max });
+
+  export const pattern = <
+    const S extends shapes.ShapeString,
+    const P extends string | RegExp,
+  >(
+    shape: S,
+    pattern: P,
+  ): shapes.Annotated<S, { pattern: P }> => as(shape, { pattern });
+
+  export const format = <
+    const S extends shapes.ShapeString,
+    const F extends string,
+  >(
+    shape: S,
+    format: F,
+  ): shapes.Annotated<S, { format: F }> => as(shape, { format });
+
+  export const uuid = <S extends shapes.ShapeString>(
+    shape: S,
+    version?: number | undefined,
+  ): shapes.Annotated<S, { pattern: RegExp }> => {
+    return as(
+      pattern(
+        shape,
+        version ?
+          new RegExp(
+            `^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`,
+          )
+        : /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/,
+      ),
+      { uuidVersion: version },
+    );
+  };
+
+  export const meta = <
+    const S extends shapes.Shape,
+    Meta extends Record<string, any>,
+  >(
+    shape: S,
+    meta: Meta,
+  ): shapes.Annotated<S, { meta: S["anno"]["meta"] & Meta }> =>
+    as(shape, { meta: { ...(shape.anno.meta || {}), ...meta } });
+}

package/src/shape/annotation.ts

@@ -0,0 +1,47 @@
+export type ReferentialAction =
+  | "cascade"
+  | "restrict"
+  | "setNull"
+  | "setDefault"
+  | "noAction";
+
+export type Annotation = {
+  optional?: boolean;
+  min?: number;
+  max?: number;
+  unique?: boolean;
+  uniqueItems?: boolean;
+  // Mapping-level multi-column UNIQUE constraints (single-column UNIQUE
+  // still lives on the column via `unique: true`).
+  uniqueConstraints?: Array<{
+    columns: string[];
+    name?: string;
+  }>;
+  primary?: boolean;
+  autoIncrement?: boolean;
+  pattern?: string | RegExp;
+  format?: string;
+  foreign?: {
+    table: string;
+    column: string;
+    onDelete?: ReferentialAction;
+    onUpdate?: ReferentialAction;
+  };
+  default?: unknown;
+  defaultExpr?: string;
+  check?: string;
+  generated?: {
+    expression: string;
+    stored: boolean;
+  };
+  schema?: string;
+  title?: string;
+  description?: string;
+  comment?: string;
+  uuidVersion?: number | undefined;
+  meta?: Record<string, any>;
+};
+
+export type AnnotatedLoose = {
+  anno: Annotation;
+};

package/src/shape/base.ts

@@ -0,0 +1,71 @@
+import { PhantomType } from "../common";
+import { Annotation } from "./annotation";
+
+export interface _ShapePhantom {
+  output: PhantomType;
+}
+
+export type _WithPhantom = {
+  _: _ShapePhantom;
+};
+
+export interface ShapeLooseBase {
+  type: string;
+  anno: Annotation;
+  _shape: true;
+  _: _ShapePhantom;
+}
+
+export type ShapeBase<
+  Type extends string,
+  Input = PhantomType,
+  Output = PhantomType,
+> = Omit<ShapeLooseBase, "_"> & {
+  type: Type;
+  input: Input;
+  anno: Annotation;
+
+  _: {
+    output: Output;
+  };
+};
+
+export type ShapeLoose<Type extends string = string> = ShapeBase<
+  Type,
+  PhantomType,
+  PhantomType
+>;
+
+export const createPhantom = (): _WithPhantom => ({}) as PhantomType;
+
+export function createBaseWithPhantom<const Type extends string>(
+  type: Type,
+): {
+  type: Type;
+  input: null;
+  anno: Annotation;
+  _shape: true;
+  _: _ShapePhantom;
+} {
+  return {
+    ...createPhantom(),
+    input: null,
+    type: type,
+    anno: {},
+    _shape: true,
+  };
+}
+
+export function createBaseWithInput<
+  const Type extends string,
+  const Input,
+  Output,
+>(type: Type, input: Input): ShapeBase<Type, Input, Output> {
+  return {
+    type: type,
+    input: input,
+    ...createPhantom(),
+    _shape: true,
+    anno: {},
+  };
+}