@constructive-io/sdk 0.21.6 → 0.21.7

package/esm/public/orm/models/schema.js

@@ -27,14 +27,18 @@ export class SchemaModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Schema', 'schemas', args.select, {
             where: args?.where,
-        }, 'SchemaFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SchemaFilter', 'SchemaOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Schema',
-            fieldName: 'schemas',
+            fieldName: 'schema',
             document,
             variables,
+            transform: (data) => ({
+                schema: data.schemas?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/schemaGrant.d.ts

@@ -15,12 +15,10 @@ export declare class SchemaGrantModel {
     } & StrictSelect<S, SchemaGrantSelect>): QueryBuilder<{
         schemaGrants: ConnectionResult<InferSelectResult<SchemaGrantWithRelations, S>>;
     }>;
-    findFirst<S extends SchemaGrantSelect>(args: FindFirstArgs<S, SchemaGrantFilter> & {
+    findFirst<S extends SchemaGrantSelect>(args: FindFirstArgs<S, SchemaGrantFilter, SchemaGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, SchemaGrantSelect>): QueryBuilder<{
-        schemaGrants: {
-            nodes: InferSelectResult<SchemaGrantWithRelations, S>[];
-        };
+        schemaGrant: InferSelectResult<SchemaGrantWithRelations, S> | null;
     }>;
     findOne<S extends SchemaGrantSelect>(args: {
         id: string;

package/esm/public/orm/models/schemaGrant.js

@@ -27,14 +27,18 @@ export class SchemaGrantModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SchemaGrant', 'schemaGrants', args.select, {
             where: args?.where,
-        }, 'SchemaGrantFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SchemaGrantFilter', 'SchemaGrantOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SchemaGrant',
-            fieldName: 'schemaGrants',
+            fieldName: 'schemaGrant',
             document,
             variables,
+            transform: (data) => ({
+                schemaGrant: data.schemaGrants?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/secretsModule.d.ts

@@ -15,12 +15,10 @@ export declare class SecretsModuleModel {
     } & StrictSelect<S, SecretsModuleSelect>): QueryBuilder<{
         secretsModules: ConnectionResult<InferSelectResult<SecretsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends SecretsModuleSelect>(args: FindFirstArgs<S, SecretsModuleFilter> & {
+    findFirst<S extends SecretsModuleSelect>(args: FindFirstArgs<S, SecretsModuleFilter, SecretsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SecretsModuleSelect>): QueryBuilder<{
-        secretsModules: {
-            nodes: InferSelectResult<SecretsModuleWithRelations, S>[];
-        };
+        secretsModule: InferSelectResult<SecretsModuleWithRelations, S> | null;
     }>;
     findOne<S extends SecretsModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/secretsModule.js

@@ -27,14 +27,18 @@ export class SecretsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SecretsModule', 'secretsModules', args.select, {
             where: args?.where,
-        }, 'SecretsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SecretsModuleFilter', 'SecretsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SecretsModule',
-            fieldName: 'secretsModules',
+            fieldName: 'secretsModule',
             document,
             variables,
+            transform: (data) => ({
+                secretsModule: data.secretsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/secureTableProvision.d.ts

@@ -15,12 +15,10 @@ export declare class SecureTableProvisionModel {
     } & StrictSelect<S, SecureTableProvisionSelect>): QueryBuilder<{
         secureTableProvisions: ConnectionResult<InferSelectResult<SecureTableProvisionWithRelations, S>>;
     }>;
-    findFirst<S extends SecureTableProvisionSelect>(args: FindFirstArgs<S, SecureTableProvisionFilter> & {
+    findFirst<S extends SecureTableProvisionSelect>(args: FindFirstArgs<S, SecureTableProvisionFilter, SecureTableProvisionOrderBy> & {
         select: S;
     } & StrictSelect<S, SecureTableProvisionSelect>): QueryBuilder<{
-        secureTableProvisions: {
-            nodes: InferSelectResult<SecureTableProvisionWithRelations, S>[];
-        };
+        secureTableProvision: InferSelectResult<SecureTableProvisionWithRelations, S> | null;
     }>;
     findOne<S extends SecureTableProvisionSelect>(args: {
         id: string;

package/esm/public/orm/models/secureTableProvision.js

@@ -27,14 +27,18 @@ export class SecureTableProvisionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SecureTableProvision', 'secureTableProvisions', args.select, {
             where: args?.where,
-        }, 'SecureTableProvisionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SecureTableProvisionFilter', 'SecureTableProvisionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SecureTableProvision',
-            fieldName: 'secureTableProvisions',
+            fieldName: 'secureTableProvision',
             document,
             variables,
+            transform: (data) => ({
+                secureTableProvision: data.secureTableProvisions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/sessionSecretsModule.d.ts

@@ -15,12 +15,10 @@ export declare class SessionSecretsModuleModel {
     } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
         sessionSecretsModules: ConnectionResult<InferSelectResult<SessionSecretsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends SessionSecretsModuleSelect>(args: FindFirstArgs<S, SessionSecretsModuleFilter> & {
+    findFirst<S extends SessionSecretsModuleSelect>(args: FindFirstArgs<S, SessionSecretsModuleFilter, SessionSecretsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SessionSecretsModuleSelect>): QueryBuilder<{
-        sessionSecretsModules: {
-            nodes: InferSelectResult<SessionSecretsModuleWithRelations, S>[];
-        };
+        sessionSecretsModule: InferSelectResult<SessionSecretsModuleWithRelations, S> | null;
     }>;
     findOne<S extends SessionSecretsModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/sessionSecretsModule.js

@@ -27,14 +27,18 @@ export class SessionSecretsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SessionSecretsModule', 'sessionSecretsModules', args.select, {
             where: args?.where,
-        }, 'SessionSecretsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SessionSecretsModuleFilter', 'SessionSecretsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SessionSecretsModule',
-            fieldName: 'sessionSecretsModules',
+            fieldName: 'sessionSecretsModule',
             document,
             variables,
+            transform: (data) => ({
+                sessionSecretsModule: data.sessionSecretsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/sessionsModule.d.ts

@@ -15,12 +15,10 @@ export declare class SessionsModuleModel {
     } & StrictSelect<S, SessionsModuleSelect>): QueryBuilder<{
         sessionsModules: ConnectionResult<InferSelectResult<SessionsModuleWithRelations, S>>;
     }>;
-    findFirst<S extends SessionsModuleSelect>(args: FindFirstArgs<S, SessionsModuleFilter> & {
+    findFirst<S extends SessionsModuleSelect>(args: FindFirstArgs<S, SessionsModuleFilter, SessionsModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SessionsModuleSelect>): QueryBuilder<{
-        sessionsModules: {
-            nodes: InferSelectResult<SessionsModuleWithRelations, S>[];
-        };
+        sessionsModule: InferSelectResult<SessionsModuleWithRelations, S> | null;
     }>;
     findOne<S extends SessionsModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/sessionsModule.js

@@ -27,14 +27,18 @@ export class SessionsModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SessionsModule', 'sessionsModules', args.select, {
             where: args?.where,
-        }, 'SessionsModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SessionsModuleFilter', 'SessionsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SessionsModule',
-            fieldName: 'sessionsModules',
+            fieldName: 'sessionsModule',
             document,
             variables,
+            transform: (data) => ({
+                sessionsModule: data.sessionsModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/site.d.ts

@@ -15,12 +15,10 @@ export declare class SiteModel {
     } & StrictSelect<S, SiteSelect>): QueryBuilder<{
         sites: ConnectionResult<InferSelectResult<SiteWithRelations, S>>;
     }>;
-    findFirst<S extends SiteSelect>(args: FindFirstArgs<S, SiteFilter> & {
+    findFirst<S extends SiteSelect>(args: FindFirstArgs<S, SiteFilter, SiteOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteSelect>): QueryBuilder<{
-        sites: {
-            nodes: InferSelectResult<SiteWithRelations, S>[];
-        };
+        site: InferSelectResult<SiteWithRelations, S> | null;
     }>;
     findOne<S extends SiteSelect>(args: {
         id: string;

package/esm/public/orm/models/site.js

@@ -27,14 +27,18 @@ export class SiteModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Site', 'sites', args.select, {
             where: args?.where,
-        }, 'SiteFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteFilter', 'SiteOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Site',
-            fieldName: 'sites',
+            fieldName: 'site',
             document,
             variables,
+            transform: (data) => ({
+                site: data.sites?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/siteMetadatum.d.ts

@@ -15,12 +15,10 @@ export declare class SiteMetadatumModel {
     } & StrictSelect<S, SiteMetadatumSelect>): QueryBuilder<{
         siteMetadata: ConnectionResult<InferSelectResult<SiteMetadatumWithRelations, S>>;
     }>;
-    findFirst<S extends SiteMetadatumSelect>(args: FindFirstArgs<S, SiteMetadatumFilter> & {
+    findFirst<S extends SiteMetadatumSelect>(args: FindFirstArgs<S, SiteMetadatumFilter, SiteMetadatumOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteMetadatumSelect>): QueryBuilder<{
-        siteMetadata: {
-            nodes: InferSelectResult<SiteMetadatumWithRelations, S>[];
-        };
+        siteMetadatum: InferSelectResult<SiteMetadatumWithRelations, S> | null;
     }>;
     findOne<S extends SiteMetadatumSelect>(args: {
         id: string;

package/esm/public/orm/models/siteMetadatum.js

@@ -27,14 +27,18 @@ export class SiteMetadatumModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SiteMetadatum', 'siteMetadata', args.select, {
             where: args?.where,
-        }, 'SiteMetadatumFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteMetadatumFilter', 'SiteMetadatumOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SiteMetadatum',
-            fieldName: 'siteMetadata',
+            fieldName: 'siteMetadatum',
             document,
             variables,
+            transform: (data) => ({
+                siteMetadatum: data.siteMetadata?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/siteModule.d.ts

@@ -15,12 +15,10 @@ export declare class SiteModuleModel {
     } & StrictSelect<S, SiteModuleSelect>): QueryBuilder<{
         siteModules: ConnectionResult<InferSelectResult<SiteModuleWithRelations, S>>;
     }>;
-    findFirst<S extends SiteModuleSelect>(args: FindFirstArgs<S, SiteModuleFilter> & {
+    findFirst<S extends SiteModuleSelect>(args: FindFirstArgs<S, SiteModuleFilter, SiteModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteModuleSelect>): QueryBuilder<{
-        siteModules: {
-            nodes: InferSelectResult<SiteModuleWithRelations, S>[];
-        };
+        siteModule: InferSelectResult<SiteModuleWithRelations, S> | null;
     }>;
     findOne<S extends SiteModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/siteModule.js

@@ -27,14 +27,18 @@ export class SiteModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SiteModule', 'siteModules', args.select, {
             where: args?.where,
-        }, 'SiteModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteModuleFilter', 'SiteModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SiteModule',
-            fieldName: 'siteModules',
+            fieldName: 'siteModule',
             document,
             variables,
+            transform: (data) => ({
+                siteModule: data.siteModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/siteTheme.d.ts

@@ -15,12 +15,10 @@ export declare class SiteThemeModel {
     } & StrictSelect<S, SiteThemeSelect>): QueryBuilder<{
         siteThemes: ConnectionResult<InferSelectResult<SiteThemeWithRelations, S>>;
     }>;
-    findFirst<S extends SiteThemeSelect>(args: FindFirstArgs<S, SiteThemeFilter> & {
+    findFirst<S extends SiteThemeSelect>(args: FindFirstArgs<S, SiteThemeFilter, SiteThemeOrderBy> & {
         select: S;
     } & StrictSelect<S, SiteThemeSelect>): QueryBuilder<{
-        siteThemes: {
-            nodes: InferSelectResult<SiteThemeWithRelations, S>[];
-        };
+        siteTheme: InferSelectResult<SiteThemeWithRelations, S> | null;
     }>;
     findOne<S extends SiteThemeSelect>(args: {
         id: string;

package/esm/public/orm/models/siteTheme.js

@@ -27,14 +27,18 @@ export class SiteThemeModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SiteTheme', 'siteThemes', args.select, {
             where: args?.where,
-        }, 'SiteThemeFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SiteThemeFilter', 'SiteThemeOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SiteTheme',
-            fieldName: 'siteThemes',
+            fieldName: 'siteTheme',
             document,
             variables,
+            transform: (data) => ({
+                siteTheme: data.siteThemes?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/spatialRelation.d.ts

@@ -15,12 +15,10 @@ export declare class SpatialRelationModel {
     } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
         spatialRelations: ConnectionResult<InferSelectResult<SpatialRelationWithRelations, S>>;
     }>;
-    findFirst<S extends SpatialRelationSelect>(args: FindFirstArgs<S, SpatialRelationFilter> & {
+    findFirst<S extends SpatialRelationSelect>(args: FindFirstArgs<S, SpatialRelationFilter, SpatialRelationOrderBy> & {
         select: S;
     } & StrictSelect<S, SpatialRelationSelect>): QueryBuilder<{
-        spatialRelations: {
-            nodes: InferSelectResult<SpatialRelationWithRelations, S>[];
-        };
+        spatialRelation: InferSelectResult<SpatialRelationWithRelations, S> | null;
     }>;
     findOne<S extends SpatialRelationSelect>(args: {
         id: string;

package/esm/public/orm/models/spatialRelation.js

@@ -27,14 +27,18 @@ export class SpatialRelationModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SpatialRelation', 'spatialRelations', args.select, {
             where: args?.where,
-        }, 'SpatialRelationFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SpatialRelationFilter', 'SpatialRelationOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SpatialRelation',
-            fieldName: 'spatialRelations',
+            fieldName: 'spatialRelation',
             document,
             variables,
+            transform: (data) => ({
+                spatialRelation: data.spatialRelations?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/sqlAction.d.ts

@@ -15,12 +15,10 @@ export declare class SqlActionModel {
     } & StrictSelect<S, SqlActionSelect>): QueryBuilder<{
         sqlActions: ConnectionResult<InferSelectResult<SqlActionWithRelations, S>>;
     }>;
-    findFirst<S extends SqlActionSelect>(args: FindFirstArgs<S, SqlActionFilter> & {
+    findFirst<S extends SqlActionSelect>(args: FindFirstArgs<S, SqlActionFilter, SqlActionOrderBy> & {
         select: S;
     } & StrictSelect<S, SqlActionSelect>): QueryBuilder<{
-        sqlActions: {
-            nodes: InferSelectResult<SqlActionWithRelations, S>[];
-        };
+        sqlAction: InferSelectResult<SqlActionWithRelations, S> | null;
     }>;
     findOne<S extends SqlActionSelect>(args: {
         id: number;

package/esm/public/orm/models/sqlAction.js

@@ -27,14 +27,18 @@ export class SqlActionModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('SqlAction', 'sqlActions', args.select, {
             where: args?.where,
-        }, 'SqlActionFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'SqlActionFilter', 'SqlActionOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'SqlAction',
-            fieldName: 'sqlActions',
+            fieldName: 'sqlAction',
             document,
             variables,
+            transform: (data) => ({
+                sqlAction: data.sqlActions?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/storageModule.d.ts

@@ -15,12 +15,10 @@ export declare class StorageModuleModel {
     } & StrictSelect<S, StorageModuleSelect>): QueryBuilder<{
         storageModules: ConnectionResult<InferSelectResult<StorageModuleWithRelations, S>>;
     }>;
-    findFirst<S extends StorageModuleSelect>(args: FindFirstArgs<S, StorageModuleFilter> & {
+    findFirst<S extends StorageModuleSelect>(args: FindFirstArgs<S, StorageModuleFilter, StorageModuleOrderBy> & {
         select: S;
     } & StrictSelect<S, StorageModuleSelect>): QueryBuilder<{
-        storageModules: {
-            nodes: InferSelectResult<StorageModuleWithRelations, S>[];
-        };
+        storageModule: InferSelectResult<StorageModuleWithRelations, S> | null;
     }>;
     findOne<S extends StorageModuleSelect>(args: {
         id: string;

package/esm/public/orm/models/storageModule.js

@@ -27,14 +27,18 @@ export class StorageModuleModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('StorageModule', 'storageModules', args.select, {
             where: args?.where,
-        }, 'StorageModuleFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'StorageModuleFilter', 'StorageModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'StorageModule',
-            fieldName: 'storageModules',
+            fieldName: 'storageModule',
             document,
             variables,
+            transform: (data) => ({
+                storageModule: data.storageModules?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/store.d.ts

@@ -15,12 +15,10 @@ export declare class StoreModel {
     } & StrictSelect<S, StoreSelect>): QueryBuilder<{
         stores: ConnectionResult<InferSelectResult<StoreWithRelations, S>>;
     }>;
-    findFirst<S extends StoreSelect>(args: FindFirstArgs<S, StoreFilter> & {
+    findFirst<S extends StoreSelect>(args: FindFirstArgs<S, StoreFilter, StoreOrderBy> & {
         select: S;
     } & StrictSelect<S, StoreSelect>): QueryBuilder<{
-        stores: {
-            nodes: InferSelectResult<StoreWithRelations, S>[];
-        };
+        store: InferSelectResult<StoreWithRelations, S> | null;
     }>;
     findOne<S extends StoreSelect>(args: {
         id: string;

package/esm/public/orm/models/store.js

@@ -27,14 +27,18 @@ export class StoreModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Store', 'stores', args.select, {
             where: args?.where,
-        }, 'StoreFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'StoreFilter', 'StoreOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Store',
-            fieldName: 'stores',
+            fieldName: 'store',
             document,
             variables,
+            transform: (data) => ({
+                store: data.stores?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/table.d.ts

@@ -15,12 +15,10 @@ export declare class TableModel {
     } & StrictSelect<S, TableSelect>): QueryBuilder<{
         tables: ConnectionResult<InferSelectResult<TableWithRelations, S>>;
     }>;
-    findFirst<S extends TableSelect>(args: FindFirstArgs<S, TableFilter> & {
+    findFirst<S extends TableSelect>(args: FindFirstArgs<S, TableFilter, TableOrderBy> & {
         select: S;
     } & StrictSelect<S, TableSelect>): QueryBuilder<{
-        tables: {
-            nodes: InferSelectResult<TableWithRelations, S>[];
-        };
+        table: InferSelectResult<TableWithRelations, S> | null;
     }>;
     findOne<S extends TableSelect>(args: {
         id: string;

package/esm/public/orm/models/table.js

@@ -27,14 +27,18 @@ export class TableModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Table', 'tables', args.select, {
             where: args?.where,
-        }, 'TableFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'TableFilter', 'TableOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Table',
-            fieldName: 'tables',
+            fieldName: 'table',
             document,
             variables,
+            transform: (data) => ({
+                table: data.tables?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/tableGrant.d.ts

@@ -15,12 +15,10 @@ export declare class TableGrantModel {
     } & StrictSelect<S, TableGrantSelect>): QueryBuilder<{
         tableGrants: ConnectionResult<InferSelectResult<TableGrantWithRelations, S>>;
     }>;
-    findFirst<S extends TableGrantSelect>(args: FindFirstArgs<S, TableGrantFilter> & {
+    findFirst<S extends TableGrantSelect>(args: FindFirstArgs<S, TableGrantFilter, TableGrantOrderBy> & {
         select: S;
     } & StrictSelect<S, TableGrantSelect>): QueryBuilder<{
-        tableGrants: {
-            nodes: InferSelectResult<TableGrantWithRelations, S>[];
-        };
+        tableGrant: InferSelectResult<TableGrantWithRelations, S> | null;
     }>;
     findOne<S extends TableGrantSelect>(args: {
         id: string;

package/esm/public/orm/models/tableGrant.js

@@ -27,14 +27,18 @@ export class TableGrantModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('TableGrant', 'tableGrants', args.select, {
             where: args?.where,
-        }, 'TableGrantFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'TableGrantFilter', 'TableGrantOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'TableGrant',
-            fieldName: 'tableGrants',
+            fieldName: 'tableGrant',
             document,
             variables,
+            transform: (data) => ({
+                tableGrant: data.tableGrants?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {

package/esm/public/orm/models/trigger.d.ts

@@ -15,12 +15,10 @@ export declare class TriggerModel {
     } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
         triggers: ConnectionResult<InferSelectResult<TriggerWithRelations, S>>;
     }>;
-    findFirst<S extends TriggerSelect>(args: FindFirstArgs<S, TriggerFilter> & {
+    findFirst<S extends TriggerSelect>(args: FindFirstArgs<S, TriggerFilter, TriggerOrderBy> & {
         select: S;
     } & StrictSelect<S, TriggerSelect>): QueryBuilder<{
-        triggers: {
-            nodes: InferSelectResult<TriggerWithRelations, S>[];
-        };
+        trigger: InferSelectResult<TriggerWithRelations, S> | null;
     }>;
     findOne<S extends TriggerSelect>(args: {
         id: string;

package/esm/public/orm/models/trigger.js

@@ -27,14 +27,18 @@ export class TriggerModel {
     findFirst(args) {
         const { document, variables } = buildFindFirstDocument('Trigger', 'triggers', args.select, {
             where: args?.where,
-        }, 'TriggerFilter', connectionFieldsMap);
+            orderBy: args?.orderBy,
+        }, 'TriggerFilter', 'TriggerOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
             operationName: 'Trigger',
-            fieldName: 'triggers',
+            fieldName: 'trigger',
             document,
             variables,
+            transform: (data) => ({
+                trigger: data.triggers?.nodes?.[0] ?? null,
+            }),
         });
     }
     findOne(args) {