supabase-tagged 0.1.0

package/index.d.ts

@@ -0,0 +1,114 @@
+import type { IsUnion, MergeDeep, OmitDeep, OptionalKeysOf, SetOptional, SimplifyDeep, TaggedUnion, UnionToIntersection } from "type-fest";
+
+type ParseTablePath<S> = S extends string
+    ? S extends `${infer Schema}.${infer Table}`
+        ? {
+            schema: Schema;
+            table: Table;
+        }
+        : never
+    : never;
+
+type TableSubtypeOptions = "Row" | "Insert" | "Update";
+
+type TableSubtype<D, S extends PropertyKey, T extends PropertyKey, Subtype extends "Row" | "Insert" | "Update"> =
+    D extends { [K in S]: { Tables: { [K in T]: { [K in Subtype]: any } } } }
+        ? D[S]["Tables"][T][Subtype]
+        : never;
+
+type Table<D, S extends PropertyKey, T extends PropertyKey> = TableSubtype<D, S, T, "Row">;
+
+type TableColumns<T> = T extends object
+    ? Extract<keyof T, string | number>
+    : never
+
+type TablesInSchema<D, S extends PropertyKey> = D extends Record<S, { Tables: infer Tables }>
+    ? Tables extends Record<infer TableName, any>
+        ? {
+            [T in TableName]: `${Extract<S, string | number>}.${Extract<T, string | number>}`
+        }[TableName]
+        : never
+    : never
+
+type AllowedTablePath<D> = D extends Record<infer Schema, unknown>
+    ? { [K in Schema]: TablesInSchema<D, K> }[Schema]
+    : never
+
+type TableMapConfigInner<Table extends object, Tag extends keyof Table> = OptionalKeysOf<Table> extends never
+    ? never
+    : IsUnion<NonNullable<Table[Tag]>> extends true
+        ? [Tag, {
+            [K in Extract<Table[Tag], number | string>]: OptionalKeysOf<Table>
+        }]
+        : never;
+
+type TableMapConfig<D, P> = ParseTablePath<P> extends { schema: infer Schema extends PropertyKey; table: infer TableName extends PropertyKey }
+    ? Table<D, Schema, TableName> extends infer T extends object
+        ? TableColumns<T> extends infer TCols extends keyof T
+            ? NonNullable<{ [C in TCols]: TableMapConfigInner<T, C> }[TCols]>
+            : never
+        : never
+    : never
+
+type TableToTaggedUnion<
+    Table extends object,
+    Tag,
+    Mapping,
+    Subtype extends TableSubtypeOptions,
+> = Tag extends keyof Table
+    ? Required<Table>[Tag] extends string
+        ? Mapping extends Record<Required<Table>[Tag], any>
+            ? TaggedUnion<Extract<Tag, string>, {
+                [MappedKey in keyof Mapping]:
+                    { [K in keyof Omit<Table, Tag | Mapping[keyof Mapping]>]: Table[K] } &
+                    { [ObjectKey in Mapping[MappedKey]]: NonNullable<Table[ObjectKey]> }
+            }> extends infer TUnion
+                ? Subtype extends "Update"
+                    ? Partial<TUnion>
+                    : Subtype extends "Insert"
+                        ? SetOptional<TUnion, Mapping[keyof Mapping] & OptionalKeysOf<Table>>
+                        : TUnion
+                : never
+            : never
+        : never
+    : never;
+
+type PrepareTableUnions<D, M> = {
+    [K in keyof M]: M[K] extends [infer TCol, infer MapConfig]
+        ? ParseTablePath<K> extends { schema: infer Schema extends PropertyKey; table: infer TableName extends PropertyKey }
+            ? {
+                [Subtype in TableSubtypeOptions as `${Extract<Schema, string>}.Tables.${Extract<TableName, string>}.${Subtype}`]:
+                    TableSubtype<D, Schema, TableName, Subtype> extends infer T extends object
+                        ? TableToTaggedUnion<T, TCol, MapConfig, Subtype>
+                        : never
+            } extends infer MappedTables
+                ? SimplifyDeep<MappedTables>
+                : never
+            : never
+        : never
+}[keyof M] extends infer MappedTablesUnion
+    ? UnionToIntersection<MappedTablesUnion>
+    : never;
+
+type PathToObject<Path extends string, Value> =
+    Path extends `${infer Head}.${infer Tail}`
+        ? { [K in Head]: PathToObject<Tail, Value> }
+        : { [K in Path]: Value };
+
+type OverrideDatabase<D, Entry> = Entry extends [infer Path extends string, infer Table]
+    ? PathToObject<Path, Table> extends infer ObjectOverride
+        ? MergeDeep<D, ObjectOverride>
+        : never
+    : never;
+
+type PreparePartialUpdates<D, Entries extends object> = {
+    [K in keyof Entries]: OverrideDatabase<D, [K, Entries[K]]>
+};
+
+type OverwriteInitialType<D, Entries extends object> = UnionToIntersection<D | PreparePartialUpdates<D, Entries>[keyof Entries]>
+
+export type Unionize<D, M extends {
+    [K in AllowedTablePath<D>]?: TableMapConfig<D, K>
+}> = PrepareTableUnions<D, M> extends infer PreparedTables extends object
+    ? OverwriteInitialType<OmitDeep<D, Extract<keyof PreparedTables, string>>, PreparedTables>
+    : never;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "supabase-tagged",
+  "version": "0.1.0",
+  "description": "A way to define tagged variants for records of a single table in Supabase",
+  "license": "(MIT OR Apache-2.0)",
+  "repository": "dsplce-co/supabase-tagged",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts"
+    }
+  },
+  "types": "./index.d.ts",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "index.d.ts"
+  ],
+  "keywords": [
+    "supabase",
+    "tagged",
+    "typescript",
+    "ts",
+    "types",
+    "utility",
+    "util",
+    "utilities"
+  ],
+  "devDependencies": {
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "type-fest": "^5.4.1"
+  }
+}