shapecraft 1.0.0

package/packages/core/node_modules/.bin/tsx

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/tsx@4.22.0/node_modules/tsx/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/tsx@4.22.0/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/tsx@4.22.0/node_modules/tsx/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/tsx@4.22.0/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../tsx/dist/cli.mjs" "$@"
+else
+  exec node  "$basedir/../tsx/dist/cli.mjs" "$@"
+fi

package/packages/core/node_modules/.bin/vitest

@@ -0,0 +1,21 @@
+#!/bin/sh
+basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
+
+case `uname` in
+    *CYGWIN*|*MINGW*|*MSYS*)
+        if command -v cygpath > /dev/null 2>&1; then
+            basedir=`cygpath -w "$basedir"`
+        fi
+    ;;
+esac
+
+if [ -z "$NODE_PATH" ]; then
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/vitest@4.1.6_@types+node@25.8.0_vite@8.0.13_@types+node@25.8.0_esbuild@0.28.0_tsx@4.22.0_/node_modules/vitest/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/vitest@4.1.6_@types+node@25.8.0_vite@8.0.13_@types+node@25.8.0_esbuild@0.28.0_tsx@4.22.0_/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules"
+else
+  export NODE_PATH="/home/ianertson/workspace/shapecraft/node_modules/.pnpm/vitest@4.1.6_@types+node@25.8.0_vite@8.0.13_@types+node@25.8.0_esbuild@0.28.0_tsx@4.22.0_/node_modules/vitest/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/vitest@4.1.6_@types+node@25.8.0_vite@8.0.13_@types+node@25.8.0_esbuild@0.28.0_tsx@4.22.0_/node_modules:/home/ianertson/workspace/shapecraft/node_modules/.pnpm/node_modules:$NODE_PATH"
+fi
+if [ -x "$basedir/node" ]; then
+  exec "$basedir/node"  "$basedir/../vitest/vitest.mjs" "$@"
+else
+  exec node  "$basedir/../vitest/vitest.mjs" "$@"
+fi

package/packages/core/node_modules/.vite/vitest/da39a3ee5e6b4b0d3255bfef95601890afd80709/results.json

@@ -0,0 +1 @@
+{"version":"4.1.6","results":[[":src/shape/transforms/json-schema/transform.test.ts",{"duration":21.738624999999956,"failed":false}],[":src/shape/transforms/sql/transform.test.ts",{"duration":16.188017000000002,"failed":false}],[":src/shape/builder.test.ts",{"duration":27.164341000000036,"failed":false}],[":src/shape/transforms/sql/from-sql.test.ts",{"duration":51.94062199999996,"failed":false}],[":src/shape/transforms/sql/transform.sqlite.test.ts",{"duration":29.056380999999988,"failed":false}],[":src/common/array.test.ts",{"duration":4.342939000000001,"failed":false}],[":src/shape/shape.test.ts",{"duration":26.323568000000023,"failed":false}],[":src/shape/tuple.test.ts",{"duration":11.398279000000002,"failed":false}]]}

package/packages/core/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@shapecraft/core",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./src/index.ts",
+  "scripts": {
+    "test": "vitest --passWithNoTests","check":
+    "tsc -p ./tsconfig.json --noEmit",
+    "format": "prettier --experimental-ternaries ./src --write",
+    "build": "tsc -p tsconfig.esm.json && tsc -p tsconfig.cjs.json"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.33.2",
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "prettier": "^3.8.3",
+    "tsx": "^4.22.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
+  },
+  "publishConfig": {
+    "main": "./dist/cjs/index.js",
+    "types": "./dist/cjs/index.d.ts",
+    "typings": "./dist/cjs/index.d.ts",
+    "exports": {
+      ".": {
+        "import": {
+          "types": "./dist/esm/index.d.ts",
+          "default": "./dist/esm/index.js"
+        },
+        "require": {
+          "types": "./dist/cjs/index.d.ts",
+          "default": "./dist/cjs/index.js"
+        },
+        "default": {
+          "types": "./dist/cjs/index.d.ts",
+          "default": "./dist/cjs/index.js"
+        }
+      }
+    }
+  }
+}

package/packages/core/src/common/array.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect } from "vitest";
+import { uniqueBy } from "./array";
+
+describe("uniqueBy", (it) => {
+  it("returns a unique array", () => {
+    const items: Array<{ firstname: string; lastname: string }> = [
+      { firstname: "john", lastname: "doe" },
+      { firstname: "john", lastname: "david" },
+      { firstname: "david", lastname: "doe" },
+      { firstname: "sarah", lastname: "sharp" },
+      { firstname: "john", lastname: "doe" },
+      { firstname: "john", lastname: "doe" },
+    ];
+
+    const un = uniqueBy(items, (x) => x.firstname);
+
+    expect(un.length).toBe(3);
+  });
+});

package/packages/core/src/common/array.ts

@@ -0,0 +1,15 @@
+export const range = (n: number): Array<number> =>
+  n < 1 ? [] : Array.from(Array(Math.trunc(n)).keys());
+
+export const uniqueBy = <T, Fn extends (x: T) => any>(
+  arr: T[],
+  fn: Fn,
+): T[] => {
+  const seen = new Set<ReturnType<Fn>>();
+  return arr.filter((x) => {
+    const k = fn(x);
+    if (seen.has(k)) return false;
+    seen.add(k);
+    return true;
+  });
+};

package/packages/core/src/common/index.ts

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

package/packages/core/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/packages/core/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/packages/core/src/common/phantom.ts

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

package/packages/core/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/packages/core/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/packages/core/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/packages/core/src/index.ts

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

package/packages/core/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/packages/core/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/packages/core/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: {},
+  };
+}