ar_sync 1.0.3 → 1.1.0

data/lib/ar_sync/instance_methods.rb

@@ -8,7 +8,7 @@ module ArSync::ModelBase::InstanceMethods
     values = {}
     self.class._each_sync_parent do |_, info|
       [*info[:watch]].each do |watch|
-        values[watch] = watch.is_a?(Proc) ? instance_exec(&watch) : send(watch)
+        values[watch] = watch.is_a?(Proc) ? instance_exec(&watch) : __send__(watch)
       end
     end
     values
@@ -33,10 +33,10 @@ module ArSync::ModelBase::InstanceMethods
   def _serializer_field_value(name)
     field = self.class._serializer_field_info name
     preloadeds = field.preloaders.map do |preloader|
-      args = [[self], nil, {}]
+      args = [[self], nil]
       preloader.call(*(preloader.arity < 0 ? args : args.take(preloader.arity)))
     end
-    instance_exec(*preloadeds, nil, {}, &field.data_block)
+    instance_exec(*preloadeds, nil, &field.data_block)
   end
 
   def _sync_current_belongs_to_info
@@ -65,11 +65,13 @@ module ArSync::ModelBase::InstanceMethods
       parents_was = parents.map { nil }
     elsif action == :destroy
       parents_was = _sync_parents_info_before_mutation
+      return unless parents_was
       parents = parents_was.map { nil }
     else
       parents_was = _sync_parents_info_before_mutation
+      return unless parents_was
       parents = _sync_current_parents_info
-      column_values_was = _sync_watch_values_before_mutation
+      column_values_was = _sync_watch_values_before_mutation || {}
       column_values = _sync_current_watch_values
     end
     parents_was.zip(parents).each do |(parent_was, info_was), (parent, info)|
@@ -109,6 +111,7 @@ module ArSync::ModelBase::InstanceMethods
 
   def _sync_notify_self
     belongs_was = _sync_belongs_to_info_before_mutation
+    return unless belongs_was
     belongs = _sync_current_belongs_to_info
     belongs.each do |name, info|
       next if belongs_was[name] == info

data/lib/ar_sync/rails.rb

@@ -94,7 +94,7 @@ module ArSync
           info = sch.class._serializer_field_info api_name
           raise ArSync::ApiNotFound, "#{type.to_s.capitalize} API named `#{api_name}` not configured" unless info
           api_params = (request[:params].as_json || {}).transform_keys(&:to_sym)
-          model = sch.instance_exec(current_user, api_params, &info.data_block)
+          model = sch.instance_exec(current_user, **api_params, &info.data_block)
           { data: yield(model, current_user, request[:query].as_json) }
         rescue StandardError => e
           { error: handle_exception(e) }

data/lib/ar_sync/type_script.rb

@@ -10,17 +10,14 @@ module ArSync::TypeScript
   end
 
   def self.generate_type_definition(api_class)
+    types = ArSerializer::TypeScript.related_serializer_types([api_class]).reject { |t| t.type == api_class }
     [
-      ArSerializer::TypeScript.generate_type_definition(api_related_classes(api_class)),
+      types.map { |t| data_type_definition t },
+      types.map { |t| query_type_definition t },
       request_type_definition(api_class)
     ].join "\n"
   end
 
-  def self.api_related_classes(api_class)
-    classes = ArSerializer::TypeScript.related_serializer_types([api_class]).map(&:type)
-    classes - [api_class]
-  end
-
   def self.request_type_definition(api_class)
     type = ArSerializer::GraphQL::TypeClass.from api_class
     definitions = []
@@ -78,24 +75,63 @@ module ArSync::TypeScript
     <<~CODE
       import { TypeRequest, ApiNameRequests } from './types'
       import { DataTypeFromRequest as DataTypeFromRequestPair } from 'ar_sync/core/DataType'
-      type DataTypeFromRequest<R extends TypeRequest> = DataTypeFromRequestPair<ApiNameRequests[R['api']], R>
+      export type NeverMatchArgument = { __nevermatch: never }
+      type DataTypeFromRequest<R extends TypeRequest | NeverMatchArgument> = NeverMatchArgument extends R ? never : R extends TypeRequest ? DataTypeFromRequestPair<ApiNameRequests[R['api']], R> : never
       export default DataTypeFromRequest
     CODE
   end
 
   def self.generate_hooks_script
     <<~CODE
-      import { useState, useEffect, useMemo } from 'react'
+      import { useState, useEffect, useMemo, useRef } from 'react'
       import { TypeRequest } from './types'
-      import DataTypeFromRequest from './DataTypeFromRequest'
+      import DataTypeFromRequest, { NeverMatchArgument } from './DataTypeFromRequest'
       import { initializeHooks, useArSyncModel as useArSyncModelBase, useArSyncFetch as useArSyncFetchBase } from 'ar_sync/core/hooks'
-      initializeHooks({ useState, useEffect, useMemo })
-      export function useArSyncModel<R extends TypeRequest>(request: R | null) {
-        return useArSyncModelBase<DataTypeFromRequest<R>>(request)
+      initializeHooks({ useState, useEffect, useMemo, useRef })
+      export function useArSyncModel<R extends TypeRequest | NeverMatchArgument>(request: R | null) {
+        return useArSyncModelBase<DataTypeFromRequest<R>>(request as TypeRequest)
       }
-      export function useArSyncFetch<R extends TypeRequest>(request: R | null) {
-        return useArSyncFetchBase<DataTypeFromRequest<R>>(request)
+      export function useArSyncFetch<R extends TypeRequest | NeverMatchArgument>(request: R | null) {
+        return useArSyncFetchBase<DataTypeFromRequest<R>>(request as TypeRequest)
       }
     CODE
   end
+
+  def self.query_type_definition(type)
+    field_definitions = type.fields.map do |field|
+      association_type = field.type.association_type
+      if association_type
+        qname = "Type#{association_type.name}Query"
+        if field.args.empty?
+          "#{field.name}?: true | #{qname} | { attributes?: #{qname} }"
+        else
+          "#{field.name}?: true | #{qname} | { params: #{field.args_ts_type}; attributes?: #{qname} }"
+        end
+      else
+        "#{field.name}?: true"
+      end
+    end
+    field_definitions << "'*'?: true"
+    query_type_name = "Type#{type.name}Query"
+    base_query_type_name = "Type#{type.name}QueryBase"
+    <<~TYPE
+      export type #{query_type_name} = keyof (#{base_query_type_name}) | Readonly<(keyof (#{base_query_type_name}))[]> | #{base_query_type_name}
+      export interface #{base_query_type_name} {
+      #{field_definitions.map { |line| "  #{line}" }.join("\n")}
+      }
+    TYPE
+  end
+
+  def self.data_type_definition(type)
+    field_definitions = []
+    type.fields.each do |field|
+      field_definitions << "#{field.name}: #{field.type.ts_type}"
+    end
+    field_definitions << "_meta?: { name: '#{type.name}'; query: Type#{type.name}QueryBase }"
+    <<~TYPE
+      export interface Type#{type.name} {
+      #{field_definitions.map { |line| "  #{line}" }.join("\n")}
+      }
+    TYPE
+  end
 end

data/lib/ar_sync/version.rb

@@ -1,3 +1,3 @@
 module ArSync
-  VERSION = '1.0.3'
+  VERSION = '1.1.0'
 end

data/lib/generators/ar_sync/install/install_generator.rb

@@ -78,7 +78,7 @@ module ArSync
         [
           '//= require ar_sync',
           '//= require action_cable',
-          '//= require ar_sync_actioncable_adapter',
+          '//= require ar_sync_action_cable_adapter',
           'ArSyncModel.setConnectionAdapter(new ArSyncActionCableAdapter(ActionCable))'
         ].join("\n") + "\n",
         before: '//= require_tree .'