Relax numeric attribute constraints

Author: wernst

.changeset/auto-create-triplit-app-changeset.md

@@ -0,0 +1,5 @@
+---
+'create-triplit-app': patch
+---
+
+Automated version bump for create-triplit-app after dependency changes

.changeset/auto-triplit-cli-changeset.md

@@ -0,0 +1,5 @@
+---
+'@triplit/cli': patch
+---
+
+Automated version bump for @triplit/cli after dependency changes

.changeset/gorgeous-turtles-tickle.md

@@ -0,0 +1,5 @@
+---
+'@triplit/db': patch
+---
+
+Relax numeric attribute constraints

packages/db/src/schema/data-types/types/type-codec.ts

@@ -76,13 +76,13 @@ export type Decoded<T extends DataType> = T extends DataType
 
 type DecodedRecord<T extends RecordType> = T extends RecordType
   ? {
-      [K in StringKey<T['properties']> as IsPropertyReadRequired<
+      [K in keyof T['properties'] as IsPropertyReadRequired<
         T['properties'][K]
       > extends true
         ? K
         : never]: Decoded<T['properties'][K]>;
     } & {
-      [K in StringKey<T['properties']> as IsPropertyReadOptional<
+      [K in keyof T['properties'] as IsPropertyReadOptional<
         T['properties'][K]
       > extends true
         ? K
@@ -114,13 +114,13 @@ export type WriteDecoded<T extends DataType> = T extends DataType
 
 type WriteDecodedRecord<T extends RecordType> = T extends RecordType
   ? {
-      [K in StringKey<T['properties']> as IsPropertyWriteRequired<
+      [K in keyof T['properties'] as IsPropertyWriteRequired<
         T['properties'][K]
       > extends true
         ? K
         : never]: WriteDecoded<T['properties'][K]>;
     } & {
-      [K in StringKey<T['properties']> as IsPropertyWriteOptional<
+      [K in keyof T['properties'] as IsPropertyWriteOptional<
         T['properties'][K]
       > extends true
         ? K

packages/db/src/schema/validation.ts

@@ -226,8 +226,6 @@ function validatePropertyName(name: string) {
   if (hasNoValue(name)) return 'property name is not defined';
   if (typeof name !== 'string') return 'property name is not a string';
   if (name.length === 0) return 'property name is empty';
-  if (/^[0-9]/.test(name))
-    return 'property name cannot start with a numeric character';
   if (!/^[a-zA-Z0-9_]+$/.test(name))
     return 'property name contains invalid characters - only alphanumeric characters and underscores are allowed.';
 }

packages/db/src/utils/types.ts

@@ -8,6 +8,7 @@ export type Not<T extends boolean> = T extends true ? false : true;
  *
  * This prevents `keyof` from returning `number | Symbol` keys
  */
+// TODO: improve this to allow for numeric keys, when changing to keyof T & (string | number) some compiler error occurs
 export type StringKey<T> = keyof T & string;
 
 /**

packages/db/test/schema-validation.spec.ts

@@ -310,20 +310,6 @@ describe('collections validation', () => {
         ).toBe(
           'schema collections definition is invalid: "test" is not a valid collection: collection schema is invalid: type record property "" is invalid: property name is empty'
         );
-        expect(
-          validateSchema({
-            collections: {
-              test: {
-                schema: S.Schema({
-                  id: S.Id(),
-                  '1name': S.String(),
-                }),
-              },
-            },
-          })
-        ).toBe(
-          'schema collections definition is invalid: "test" is not a valid collection: collection schema is invalid: type record property "1name" is invalid: property name cannot start with a numeric character'
-        );
         expect(
           validateSchema({
             collections: {

packages/db/test/type-record.spec.ts

@@ -864,3 +864,42 @@ describe('Nested Properties', () => {
     });
   });
 });
+
+it('allows numeric keys', async () => {
+  const db = new DB({
+    schema: {
+      collections: {
+        test: {
+          schema: S.Schema({
+            id: S.Id(),
+            24: S.String(),
+            nested: S.Record({
+              25: S.String(),
+            }),
+          }),
+        },
+      },
+    },
+  });
+  await db.insert('test', {
+    id: 'item1',
+    24: 'value',
+    nested: { 25: 'nested value' },
+  });
+  const result = await db.fetchById('test', 'item1');
+  expect(result).toEqual({
+    id: 'item1',
+    24: 'value',
+    nested: { 25: 'nested value' },
+  });
+  await db.update('test', 'item1', async (entity) => {
+    entity[24] = 'updated value';
+    entity.nested[25] = 'updated nested value';
+  });
+  const updatedResult = await db.fetchById('test', 'item1');
+  expect(updatedResult).toEqual({
+    id: 'item1',
+    24: 'updated value',
+    nested: { 25: 'updated nested value' },
+  });
+});

packages/db/test/typecheck/utils.ts

@@ -66,6 +66,8 @@ export type ExhaustiveSchemaSelectAll = {
   defaultString: string;
   enumString: 'a' | 'b' | 'c';
   nullableEnumString?: 'a' | 'b' | 'c' | null | undefined;
+
+  42: string;
 };
 
 export type ExhaustiveSchemaInsert = {
@@ -125,4 +127,6 @@ export type ExhaustiveSchemaInsert = {
   defaultString?: string | null | undefined;
   enumString: 'a' | 'b' | 'c';
   nullableEnumString?: 'a' | 'b' | 'c' | null | undefined;
+
+  42: string;
 };

packages/db/test/utils/exhaustive-schema.ts

@@ -74,6 +74,9 @@ export const EXHAUSTIVE_SCHEMA = {
           enum: ['a', 'b', 'c'],
           nullable: true,
         }),
+
+        // Numeric key
+        42: S.String(),
       }),
       relationships: {
         subquery: {