npm - @casekit/orm - Versions diffs - 0.0.1-alpha.15 → 0.0.1-alpha.17 - Mend

@@ -0,0 +1,6 @@
+import { LooseModelDefinition } from "../schema/types/loose/LooseModelDefinition";
+export type ColumnName<Model extends LooseModelDefinition> = Extract<
+    keyof Model["columns"],
+    string
+>;

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { SuggestedColumnType } from "../schema/populate/suggestedColumnSchema";
+import { LooseModelDefinition } from "../schema/types/loose/LooseModelDefinition";
+import { ColumnName } from "./ColumnName";
+type NonNullableColumnType<
+    Model extends LooseModelDefinition,
+    C extends ColumnName<Model>,
+> =
+    Model["columns"][C]["zodSchema"] extends z.ZodType<unknown>
+        ? z.infer<Model["columns"][C]["zodSchema"]>
+        : SuggestedColumnType<Model["columns"][C]["type"]>;
+export type ColumnType<
+    Model extends LooseModelDefinition,
+    C extends ColumnName<Model>,
+> = Model["columns"][C]["nullable"] extends true
+    ? NonNullableColumnType<Model, C> | null
+    : NonNullableColumnType<Model, C>;

@@ -0,0 +1,21 @@
+import pg from "pg";
+import { Middleware } from "../queries/middleware/Middleware";
+import { LooseModelDefinitions } from "../schema/types/loose/LooseModelDefinitions";
+import { LooseRelationsDefinitions } from "../schema/types/loose/LooseRelationsDefinitions";
+export type Configuration<
+    Models extends LooseModelDefinitions,
+    Relations extends LooseRelationsDefinitions<Models>,
+> = {
+    models: Models;
+    relations?: Relations;
+    extensions?: string[];
+    schema?: string;
+    naming?: {
+        column?: (s: string) => string;
+        table?: (s: string) => string;
+    };
+    pool: pg.Pool;
+    middleware?: Middleware[];
+};

@@ -0,0 +1,20 @@
+import { IsNullable } from "../schema/types/helpers/IsNullable";
+import { LooseModelDefinition } from "../schema/types/loose/LooseModelDefinition";
+import { ColumnName } from "./ColumnName";
+import { ColumnType } from "./ColumnType";
+import { Simplify } from "./util/Simplify";
+export type NullableColumn<Model extends LooseModelDefinition> = {
+    [C in ColumnName<Model>]: IsNullable<Model, C> extends true ? C : never;
+}[ColumnName<Model>];
+export type ModelType<Model extends LooseModelDefinition> = Simplify<
+    {
+        [C in Exclude<ColumnName<Model>, NullableColumn<Model>>]: ColumnType<
+            Model,
+            C
+        >;
+    } & {
+        [C in NullableColumn<Model>]?: ColumnType<Model, C>;
+    }
+>;

@@ -0,0 +1,7 @@
+export type DeepRequired<T> = T extends (...args: unknown[]) => unknown
+    ? T
+    : T extends Record<string, unknown>
+      ? { [K in keyof T]-?: Exclude<DeepRequired<T[K]>, null | undefined> }
+      : T extends [infer Head, ...infer Tail]
+        ? [DeepRequired<Head>, ...DeepRequired<Tail>]
+        : T;

@@ -0,0 +1,5 @@
+export type DisallowExtraKeys<Base, T extends Base> = {
+    [K in keyof T]: T[K];
+} & {
+    [K in keyof T as K extends keyof Base ? never : K]: never;
+};

@@ -0,0 +1,8 @@
+export type Simplify<T> = {
+    [K in keyof T]: T[K] extends Date
+        ? T[K]
+        : T[K] extends object
+          ? Simplify<T[K]>
+          : T[K];
+    // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+} & unknown;

@@ -0,0 +1,4 @@
+/**
+ * Ensure that the input is an array. If it is not an array, wrap it in an array.
+ */
+export const ensureArray = <T>(x: T | T[]): T[] => (Array.isArray(x) ? x : [x]);

@@ -0,0 +1,35 @@
+import { describe, expect, test } from "vitest";
+import { interleave } from "./interleave";
+describe("interleave", () => {
+    test("it interleaves a value between elements of a list", () => {
+        expect(interleave([1, 2, 3], "x")).toEqual([1, "x", 2, "x", 3]);
+    });
+    test("it works with empty lists", () => {
+        expect(interleave([], "x")).toEqual([]);
+    });
+    test("it works with long lists", () => {
+        expect(interleave([1, 2, 3, 1, 2, 3, 1, 2, 3], "x")).toEqual([
+            1,
+            "x",
+            2,
+            "x",
+            3,
+            "x",
+            1,
+            "x",
+            2,
+            "x",
+            3,
+            "x",
+            1,
+            "x",
+            2,
+            "x",
+            3,
+        ]);
+    });
+});

@@ -0,0 +1,8 @@
+export const interleave = <T, U>(xs: T[], y: U): (T | U)[] => {
+    const zs: (T | U)[] = [];
+    xs.forEach((x, index) => {
+        zs.push(x);
+        if (index < xs.length - 1) zs.push(y);
+    });
+    return zs;
+};

	@@ -0,0 +1 @@
1	+ export type NonEmptyArray<T> = [T, ...T[]];

@casekit/orm 0.0.1-alpha.15 → 0.0.1-alpha.17